rsass 0.29.2

Sass implementation in pure rust (not complete yet)
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

use super::SrcValue;
use crate::value::{Numeric, ValueRange};
use crate::{Error, Invalid, ScopeRef};

#[derive(Clone, Debug, PartialEq, Eq, PartialOrd)]
pub struct SrcRange {
    from: SrcValue,
    to: SrcValue,
    inclusive: bool,
}

impl SrcRange {
    pub fn evaluate(&self, scope: ScopeRef) -> Result<ValueRange, Error> {
        let (from, unit) = self.from.eval_map(scope.clone(), |v| {
            let v = v
                .numeric_value()
                .map_err(|v| Invalid::not(&v, "a number"))?;
            let unit = v.unit;
            let v = v.value.into_integer().map_err(|e| {
                Invalid::not(&Numeric::new(e, unit.clone()), "an int")
            })?;

            Ok((v, unit))
        })?;
        let to = self.to.eval_map(scope.clone(), |v| {
            let v = v
                .numeric_value()
                .map_err(|v| Invalid::not(&v, "a number"))?;

            let v = if unit.is_none() || v.is_no_unit() {
                v.value
            } else if let Some(scaled) = v.as_unitset(&unit) {
                scaled
            } else {
                return Err(Invalid::expected_to(
                    &v,
                    &format!("have unit {unit}"),
                ));
            };

            let v = v.into_integer().map_err(|e| {
                Invalid::not(&Numeric::new(e, unit.clone()), "an int")
            })?;

            Ok(v)
        })?;
        Ok(ValueRange::new(from, to, self.inclusive, unit))
    }
}

pub mod parser {
    use super::SrcRange;
    use crate::parser::util::ignore_comments;
    use crate::parser::{single_value_p, PResult, Span};
    use nom::branch::alt;
    use nom::bytes::complete::tag;
    use nom::combinator::value;
    use nom::sequence::{delimited, terminated};
    use nom::Parser as _;

    pub fn src_range(input: Span) -> PResult<SrcRange> {
        let (input, from) = delimited(
            terminated(tag("from"), ignore_comments),
            single_value_p,
            ignore_comments,
        )
        .parse(input)?;
        let (input, inclusive) = terminated(
            alt((value(true, tag("through")), value(false, tag("to")))),
            ignore_comments,
        )
        .parse(input)?;
        let (input, to) =
            terminated(single_value_p, ignore_comments).parse(input)?;
        Ok((
            input,
            SrcRange {
                from,
                to,
                inclusive,
            },
        ))
    }
}