float-pigment-css 0.8.2

The CSS parser for the float-pigment project.
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

use cssparser::{ParseError, Parser, Token};

use crate::{
    parser::{property_value::custom_ident_repr, CustomError, ParseState},
    sheet::PropertyMeta,
    typing::GridAutoFlow,
};

#[inline(never)]
pub(crate) fn line_names<'a, 't: 'a, 'i: 't>(
    parser: &'a mut Parser<'i, 't>,
    properties: &mut [PropertyMeta],
    st: &mut ParseState,
) -> Result<Vec<String>, ParseError<'i, CustomError>> {
    let next = parser.next()?;
    if let Token::SquareBracketBlock = next {
        let line_names = parser.parse_nested_block(|parser| {
            let mut line_names = Vec::with_capacity(1);
            while !parser.is_exhausted() {
                let line_name = custom_ident_repr(parser, properties, st)?;
                line_names.push(line_name);
            }
            Ok(line_names)
        })?;
        return Ok(line_names);
    }
    let next = next.clone();
    Err(parser.new_unexpected_token_error(next))
}

#[inline(never)]
pub(crate) fn fr_repr<'a, 't: 'a, 'i: 't>(
    parser: &'a mut Parser<'i, 't>,
    _properties: &mut [PropertyMeta],
    _st: &mut ParseState,
) -> Result<f32, ParseError<'i, CustomError>> {
    let next = parser.next()?;
    match next {
        Token::Dimension { value, unit, .. } => match unit as &str {
            "fr" => return Ok(*value),
            _ => {}
        },
        _ => {}
    }
    let next = next.clone();
    Err(parser.new_unexpected_token_error(next))
}

#[inline(never)]
pub(crate) fn grid_auto_flow_repr<'a, 't: 'a, 'i: 't>(
    parser: &'a mut Parser<'i, 't>,
    _properties: &mut [PropertyMeta],
    _st: &mut ParseState,
) -> Result<GridAutoFlow, ParseError<'i, CustomError>> {
    #[derive(PartialEq, Clone, Copy)]
    enum FlowDirection {
        Row,
        Column,
    }
    let mut flow_direction = None;
    let mut dense = false;
    while !parser.is_exhausted() {
        let next = parser.next()?;
        match next {
            Token::Ident(ident) => {
                let ident: &str = ident;
                match ident {
                    "row" if flow_direction.is_none() => {
                        flow_direction.replace(FlowDirection::Row);
                    }
                    "column" if flow_direction.is_none() => {
                        flow_direction.replace(FlowDirection::Column);
                    }
                    "dense" if !dense => {
                        dense = true;
                    }
                    _ => {
                        let next = next.clone();
                        return Err(parser.new_unexpected_token_error(next));
                    }
                }
            }
            _ => {
                let next = next.clone();
                return Err(parser.new_unexpected_token_error(next));
            }
        }
    }
    match (flow_direction, dense) {
        (Some(FlowDirection::Row), true) => Ok(GridAutoFlow::RowDense),
        (Some(FlowDirection::Column), true) => Ok(GridAutoFlow::ColumnDense),
        (Some(FlowDirection::Row), false) => Ok(GridAutoFlow::Row),
        (Some(FlowDirection::Column), false) => Ok(GridAutoFlow::Column),
        (None, true) => Ok(GridAutoFlow::RowDense),
        (None, _) => Err(parser.new_custom_error(CustomError::Unmatched)),
    }
}