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

use super::strings::name;
use super::util::{ignore_comments, opt_spacelike};
use super::value::space_list;
use super::{PResult, Span};
use crate::sass::{CallArgs, FormalArgs, Name};
use nom::bytes::complete::tag;
use nom::character::complete::char;
use nom::combinator::{cut, map, map_res, opt};
use nom::error::context;
use nom::multi::separated_list0;
use nom::sequence::{delimited, pair, preceded, terminated};
use nom::Parser as _;

pub fn formal_args(input: Span) -> PResult<FormalArgs> {
    let (input, _) = terminated(char('('), opt_spacelike).parse(input)?;
    let (input, v) = separated_list0(
        preceded(tag(","), opt_spacelike),
        map(
            pair(
                delimited(tag("$"), name, opt_spacelike),
                opt(delimited(
                    terminated(tag(":"), opt_spacelike),
                    cut(context("Expected expression.", space_list)),
                    opt_spacelike,
                )),
            ),
            |(name, d)| (name.into(), d),
        ),
    )
    .parse(input)?;
    let (input, va) = if !v.is_empty() {
        terminated(
            opt(tag("...")),
            preceded(opt_spacelike, terminated(opt(tag(",")), opt_spacelike)),
        )
        .parse(input)?
    } else {
        (input, None)
    };
    let (input, _) = char(')')(input)?;
    Ok((
        input,
        if va.is_none() {
            FormalArgs::new(v)
        } else {
            FormalArgs::new_va(v)
        },
    ))
}

pub fn call_args(input: Span) -> PResult<CallArgs> {
    delimited(
        terminated(char('('), opt_spacelike),
        map_res(
            |input| {
                let (input, args) = separated_list0(
                    terminated(tag(","), opt_spacelike),
                    pair(
                        opt(map(
                            delimited(
                                tag("$"),
                                name,
                                delimited(
                                    ignore_comments,
                                    char(':'),
                                    opt_spacelike,
                                ),
                            ),
                            Name::from,
                        )),
                        terminated(space_list, opt_spacelike),
                    ),
                )
                .parse(input)?;
                let (input, trail) = if !args.is_empty() {
                    opt(terminated(char(','), opt_spacelike)).parse(input)?
                } else {
                    (input, None)
                };
                Ok((input, (args, trail)))
            },
            |(args, trail)| CallArgs::new(args, trail.is_some()),
        ),
        cut(char(')')),
    )
    .parse(input)
}