rsass 0.25.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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use super::options::Options;
use super::writestr::WriteStr;
use super::{fn_name, ignore, Error, TestRunner};
use lazy_static::lazy_static;
use regex::Regex;
use std::io::Write;

pub struct TestFixture {
    name: Option<String>,
    input: String,
    expectation: TestExpectation,
    options: Options,
}

enum TestExpectation {
    ExpectedCSS(String),
    ExpectedError(String),
}

use TestExpectation::{ExpectedCSS, ExpectedError};

impl TestFixture {
    pub fn new_ok(
        name: Option<String>,
        input: String,
        expected_css: &str,
        options: Options,
    ) -> Self {
        TestFixture {
            name,
            input,
            expectation: ExpectedCSS(normalize_output_css(expected_css)),
            options,
        }
    }

    pub fn new_err(
        name: Option<String>,
        input: String,
        error: String,
        options: Options,
    ) -> Self {
        TestFixture {
            name,
            input,
            expectation: ExpectedError(error),
            options,
        }
    }

    pub fn write_test(
        &self,
        rs: &mut dyn Write,
        runner: TestRunner,
    ) -> Result<(), Error> {
        if let Some(ref reason) = self.options.should_skip {
            ignore(rs, &self.name, reason)?;
            return Ok(());
        }
        let has_files = runner.has_files();
        rs.write_all(b"#[test]\n")?;
        if let Some(reason) = self.is_failure(runner) {
            writeln!(rs, "#[ignore] // {}", reason)?;
        }
        let fname = self.name.as_deref().map(fn_name);
        writeln!(rs, "fn {}() {{", fname.as_deref().unwrap_or("test"))?;
        let runner = if self.options.precision.is_some()
            || (has_files && self.name.is_some())
        {
            rs.write_all(b"    let runner = runner()")?;
            if let Some(p) = self.options.precision {
                write!(rs, ".set_precision({});", p)?;
            }
            if has_files {
                if let Some(name) = &self.name {
                    write!(rs, ".with_cwd({:?})", name)?;
                }
            }
            rs.write_all(b";\n")?;
            "runner"
        } else {
            "runner()"
        };
        match self.expectation {
            ExpectedError(ref err) => {
                writeln!(
                    rs,
                    "    assert_eq!(\
                     \n        {}.err(\
                     \n            {}\
                     \n        ),\
                     \n        {},\
                     \n    );",
                    runner,
                    WriteStr(&self.input, 13),
                    WriteStr(err, 9),
                )?;
            }
            ExpectedCSS(ref expected) => {
                writeln!(
                    rs,
                    "    assert_eq!(\
                     \n        {}.ok(\
                     \n            {}\
                     \n        ),\
                     \n        {}\
                     \n    );",
                    runner,
                    WriteStr(&self.input, 13),
                    WriteStr(expected, 9),
                )?;
            }
        }
        rs.write_all(b"}\n")?;
        Ok(())
    }

    /// Execute the test here and now, return None for success or Some reason to fail.
    fn is_failure(&self, runner: TestRunner) -> Option<&'static str> {
        let runner = if let Some(precision) = self.options.precision {
            runner.set_precision(precision as usize)
        } else {
            runner
        };
        match (&self.expectation, runner.run(&self.input)) {
            (ExpectedError(_), Ok(_)) => Some("missing error"),
            (ExpectedError(ref expected), Err(ref actual)) => {
                // TODO: some flexibility in comparision?
                if expected == actual {
                    None
                } else {
                    Some("wrong error")
                }
            }
            (ExpectedCSS(ref expected), Ok(ref actual)) => {
                if expected == actual {
                    None
                } else {
                    Some("wrong result")
                }
            }
            (ExpectedCSS(_), Err(_)) => Some("unexepected error"),
        }
    }
}

fn normalize_output_css(css: &str) -> String {
    // Normalizes the whitespace in the given CSS to make it easier to compare. Based on:
    // https://github.com/sass/sass-spec/blob/0f59164aabb3273645fda068d0fb1b879aa3f1dc/lib/sass_spec/util.rb#L5-L7
    // NOTE: This is done on input and expected output.
    // The actual result is normalized in a simler way in the rsass function in generated tests.
    lazy_static! {
        static ref RE: Regex = Regex::new("(?:\r?\n)+").unwrap();
    }
    RE.replace_all(css, "\n").to_string()
}