malva 0.16.0

Configurable, smart and fast CSS, SCSS, Sass and Less formatter.
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

use super::super::DocGen;
use crate::{ctx::Ctx, state::State};
use raffia::{Spanned, ast::*};
use tiny_pretty::Doc;

impl<'a, 's: 'a> DocGen<'a, 's> for ImportPrelude<'s> {
    fn doc(&self, ctx: &Ctx<'a, 's>, state: &State) -> Doc<'s> {
        let mut docs = Vec::with_capacity(3);
        docs.push(self.href.doc(ctx, state));
        let mut pos = self.href.span().end;

        if let Some(layer) = &self.layer {
            let span = layer.span();
            docs.push(Doc::line_or_space());
            docs.extend(ctx.end_spaced_comments(ctx.get_comments_between(pos, span.start)));
            docs.push(layer.doc(ctx, state));
            pos = span.end;
        }

        if let Some(supports) = &self.supports {
            let span = supports.span();
            docs.push(Doc::line_or_space());
            docs.extend(ctx.end_spaced_comments(ctx.get_comments_between(pos, span.start)));
            docs.push(supports.doc(ctx, state));
            pos = span.end;
        }

        if let Some(media) = &self.media {
            docs.push(Doc::line_or_space());
            docs.extend(ctx.end_spaced_comments(ctx.get_comments_between(pos, media.span.start)));
            docs.push(media.doc(ctx, state));
        }

        Doc::list(docs).group().nest(ctx.indent_width)
    }
}

impl<'a, 's: 'a> DocGen<'a, 's> for ImportPreludeHref<'s> {
    fn doc(&self, ctx: &Ctx<'a, 's>, state: &State) -> Doc<'s> {
        match self {
            ImportPreludeHref::Str(str) => str.doc(ctx, state),
            ImportPreludeHref::Url(url) => url.doc(ctx, state),
        }
    }
}

impl<'a, 's: 'a> DocGen<'a, 's> for ImportPreludeLayer<'s> {
    fn doc(&self, ctx: &Ctx<'a, 's>, state: &State) -> Doc<'s> {
        match self {
            ImportPreludeLayer::Empty(empty) => empty.doc(ctx, state),
            ImportPreludeLayer::WithName(with_name) => with_name.doc(ctx, state),
        }
    }
}

impl<'a, 's: 'a> DocGen<'a, 's> for ImportPreludeSupports<'s> {
    fn doc(&self, ctx: &Ctx<'a, 's>, state: &State) -> Doc<'s> {
        let kind_span = self.kind.span();
        Doc::text("supports(")
            .concat(
                ctx.end_spaced_comments(ctx.get_comments_between(self.span.start, kind_span.start)),
            )
            .append(match &self.kind {
                ImportPreludeSupportsKind::SupportsCondition(supports_condition) => {
                    supports_condition.doc(ctx, state)
                }
                ImportPreludeSupportsKind::Declaration(declaration) => declaration.doc(ctx, state),
            })
            .concat(
                ctx.start_spaced_comments(ctx.get_comments_between(kind_span.end, self.span.end)),
            )
            .append(Doc::char(')'))
    }
}