oak-sass 0.0.11

High-performance incremental Sass parser for the oak ecosystem with flexible configuration, supporting CSS preprocessing and styling.
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
121
122
123
124
125
126
127
128
129
130
131
132
133

#![doc = include_str!("readme.md")]
use core::range::Range;

/// Root node of the Sass AST.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SassRoot {
    /// Statements in the Sass file.
    pub statements: Vec<SassStatement>,
    /// Source code span of the entire Sass file
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Represents a Sass statement.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SassStatement {
    /// Variable definition: `$name: value;`
    VariableDefinition(VariableDefinition),
    /// Rule set: `selector { properties and nested rules }`
    RuleSet(RuleSet),
    /// At-rule: `@import`, `@media`, etc.
    AtRule(AtRule),
    /// CSS property within a ruleset or at-rule
    Property(Property),
    /// Error node for fault tolerance
    Error(ErrorNode),
}

/// Error node for fault tolerance
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ErrorNode {
    /// The error message describing what went wrong during parsing.
    pub message: String,
    /// Source code span where the error occurred.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Variable definition: `$name: value;`
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct VariableDefinition {
    /// Source code span of the variable name (without the `$` prefix).
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub name: Range<usize>,
    /// Source code span of the variable value expression.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub value: Range<usize>,
    /// Source code span of the entire variable definition.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// Rule set: `selector { properties and nested rules }`
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RuleSet {
    /// Source code span of the CSS selector.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub selector: Range<usize>,
    /// Nested child statements within this rule set.
    pub children: Vec<SassStatement>,
    /// CSS properties defined directly in this rule set.
    pub properties: Vec<Property>,
    /// Source code span of the entire rule set including selector and braces.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// CSS property: `name: value;`
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Property {
    /// Source code span of the property name.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub name: Range<usize>,
    /// Source code span of the property value.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub value: Range<usize>,
    /// Source code span of the entire property declaration including the semicolon.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

/// At-rule: `@name ...`
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct AtRule {
    /// Source code span of the at-rule name (without the `@` prefix).
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub name: Range<usize>,
    /// Optional source code span of the at-rule parameters.
    #[cfg_attr(feature = "serde", serde(with = "serde_range_opt"))]
    pub params: Option<Range<usize>>,
    /// Optional body containing nested statements for at-rules with braces.
    pub body: Option<Vec<SassStatement>>,
    /// Source code span of the entire at-rule.
    #[cfg_attr(feature = "serde", serde(with = "oak_core::serde_range"))]
    pub span: Range<usize>,
}

#[cfg(feature = "serde")]
mod serde_range_opt {
    use super::*;
    use serde::{Deserialize, Deserializer, Serializer};

    pub fn serialize<S>(value: &Option<Range<usize>>, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match value {
            Some(range) => oak_core::serde_range::serialize(range, serializer),
            None => serializer.serialize_none(),
        }
    }

    #[derive(Deserialize)]
    struct RangeDef {
        start: usize,
        end: usize,
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<Range<usize>>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let opt: Option<RangeDef> = Option::deserialize(deserializer)?;
        Ok(opt.map(|def| Range { start: def.start, end: def.end }))
    }
}