typstyle-core 0.15.0

A pretty printer for typst.
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

use crate::pretty::{PrettyPrinter, prelude::*};

/// An item in the flow. A space is added only when the item before and the item after both allow it.
pub struct FlowItem<'a>(pub Option<FlowItemRepr<'a>>);

pub struct FlowItemRepr<'a> {
    pub doc: ArenaDoc<'a>,
    /// Whether a space can be added before the doc.
    pub space_before: bool,
    /// Whether a space can be added after the doc.
    pub space_after: bool,
}

impl<'a> FlowItem<'a> {
    pub fn new(doc: ArenaDoc<'a>, space_before: bool, space_after: bool) -> Self {
        Self(Some(FlowItemRepr {
            doc,
            space_before,
            space_after,
        }))
    }

    /// Create an item that allows spaces before and after.
    pub fn spaced(doc: ArenaDoc<'a>) -> Self {
        Self::new(doc, true, true)
    }

    /// Create an item that allows space before.
    pub fn spaced_before(doc: ArenaDoc<'a>, space_after: bool) -> Self {
        Self::new(doc, true, space_after)
    }

    /// Create an item that disallows space before but allows space after.
    pub fn tight_spaced(doc: ArenaDoc<'a>) -> Self {
        Self::new(doc, false, true)
    }

    /// Create an item that disallows space after but allows space before.
    pub fn spaced_tight(doc: ArenaDoc<'a>) -> Self {
        Self::new(doc, true, false)
    }

    /// Create an item that disallows space before and after.
    pub fn tight(doc: ArenaDoc<'a>) -> Self {
        Self::new(doc, false, false)
    }

    pub const fn none() -> Self {
        Self(None)
    }
}

pub struct FlowStylist<'a> {
    printer: &'a PrettyPrinter<'a>,
    doc: ArenaDoc<'a>,
    space_after: bool,
    at_line_start: bool,
}

impl<'a> FlowStylist<'a> {
    pub fn new(printer: &'a PrettyPrinter<'a>) -> Self {
        Self {
            doc: printer.arena.nil(),
            printer,
            space_after: false,
            at_line_start: true,
        }
    }

    pub fn push_comment(&mut self, doc: ArenaDoc<'a>, is_block: bool) {
        if is_block {
            self.push_doc(doc, true, true);
        } else {
            if !self.at_line_start {
                self.space_after = true;
            }
            self.push_doc(doc, true, false);
        }
    }

    pub fn push_doc(&mut self, doc: ArenaDoc<'a>, space_before: bool, space_after: bool) {
        if space_before && self.space_after {
            self.doc += self.printer.arena.space();
        }
        self.doc += doc;
        self.space_after = space_after;
        self.at_line_start = false;
    }

    pub fn enter_new_line(&mut self) {
        self.at_line_start = true;
    }

    pub fn into_doc(self) -> ArenaDoc<'a> {
        self.doc
    }
}