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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use super::{is_special, CallError};
use crate::css::Value;
use crate::value::ListSeparator;

/// Channels data is either four values of parsable data, or one value
/// of "special" data, that is probably a sass list.
// only used temporarily for evaluating color function arguments.
#[allow(clippy::large_enum_variant)]
pub enum Channels {
    Data([Value; 4]),
    Special(Value),
}

impl TryFrom<Value> for Channels {
    type Error = ChaError;
    fn try_from(channels: Value) -> Result<Self, ChaError> {
        use crate::value::Operator::Div;
        match &channels {
            c if is_special(c) => Ok(Self::Special(channels)),
            Value::List(_, _, true) => Err(ChaError::Bracketed),
            Value::List(_, Some(ListSeparator::Comma), _) => {
                Err(ChaError::BadSep)
            }
            Value::List(v, Some(ListSeparator::Slash), _) => match &v[..] {
                [Value::List(_, _, true), _] => Err(ChaError::Bracketed),
                [Value::List(_, Some(i_s), _), _]
                    if *i_s != ListSeparator::Space =>
                {
                    Err(ChaError::BadSep)
                }
                [Value::List(inner, _, _), a] => Ok(inner_channels(inner)?
                    .map(|[c1, c2, c3]| Self::Data([c1, c2, c3, a.clone()]))
                    .unwrap_or_else(|| Self::Special(channels))),
                [h, _a] if is_special(h) => Ok(Self::Special(channels)),
                [_, _] => Err(ChaError::Missing1),
                list => Err(ChaError::SlashBadNum(list.len())),
            },
            Value::List(vec, _, false) => match &vec[..] {
                [r, g, Value::BinOp(op)] if op.op() == Div => {
                    Ok(Self::Data([
                        r.clone(),
                        g.clone(),
                        op.a().clone(),
                        op.b().clone(),
                    ]))
                }
                other => Ok(inner_channels(other)?
                    .map(|[c1, c2, c3]| Self::Data([c1, c2, c3, Value::Null]))
                    .unwrap_or_else(|| Self::Special(channels))),
            },
            _ => Err(ChaError::Missing1),
        }
    }
}

fn inner_channels(
    channels: &[Value],
) -> Result<Option<[Value; 3]>, ChaError> {
    match channels {
        [h, s, l] => Ok(Some([h.clone(), s.clone(), l.clone()])),
        [] => Err(ChaError::Missing0),
        [h] => {
            if is_special(h) {
                Ok(None)
            } else {
                Err(ChaError::Missing1)
            }
        }
        [h, s] => {
            if is_special(h) || is_special(s) {
                Ok(None)
            } else {
                Err(ChaError::Missing2)
            }
        }
        list => Err(ChaError::BadNum(list.len())),
    }
}

pub enum ChaError {
    /// $channels must be an unbracketed list
    Bracketed,
    /// $channels must be a space-separated list
    BadSep,
    Missing0,
    Missing1,
    Missing2,
    /// "Only 3 elements allowed, but {} were passed",
    BadNum(usize),
    SlashBadNum(usize),
}

impl ChaError {
    pub fn conv(self, names: &[&'static str; 3]) -> CallError {
        match self {
            Self::Bracketed => {
                CallError::msg("$channels must be an unbracketed list.")
            }
            Self::BadSep => {
                CallError::msg("$channels must be a space-separated list.")
            }
            Self::Missing0 => {
                CallError::msg(format!("Missing element ${}.", names[0]))
            }
            Self::Missing1 => {
                CallError::msg(format!("Missing element ${}.", names[1]))
            }
            Self::Missing2 => {
                CallError::msg(format!("Missing element ${}.", names[2]))
            }
            Self::BadNum(n) => CallError::msg(format!(
                "Only 3 elements allowed, but {n} were passed.",
            )),
            Self::SlashBadNum(n) => CallError::msg(format!(
                "Only 2 slash-separated elements allowed, but {n} {} passed.",
                if n == 1 { "was" } else { "were" },
            )),
        }
    }
}