microcad-lang-format 0.5.0

µcad language 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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

// Copyright © 2026 The µcad authors <info@microcad.xyz>
// SPDX-License-Identifier: AGPL-3.0-or-later

use microcad_lang_parse::ast;

use crate::{Format, FormatConfig, Node, node};

pub(crate) fn leading_extras_without_newline(extras: &ast::ItemExtras) -> ast::ItemExtras {
    let mut leading = extras.leading.clone();
    if let Some(ast::ItemExtra::Whitespace(ws)) = leading.0.first_mut() {
        // Find the index of the first newline
        if let Some(pos) = ws.find('\n') {
            // Remove only that specific character
            ws.remove(pos);
        }
    }

    ast::ItemExtras {
        leading,
        trailing: extras.trailing.clone(),
    }
}

impl Format for ast::LeadingExtras {
    fn format(&self, f: &FormatConfig) -> Node {
        let mut prev_newline = false;

        let node: Node = self
            .0
            .iter()
            .map(|extra| match &extra {
                ast::ItemExtra::Comment(comment) => {
                    let node = comment.format(f);
                    prev_newline = node.ends_with_hardline();
                    node
                }
                ast::ItemExtra::Whitespace(ws) => ws
                    .chars()
                    .filter(|&c| c == '\n')
                    .map(|_| Node::Hardline)
                    .skip(if prev_newline { 1 } else { 0 })
                    .take(2)
                    .collect::<Vec<Node>>()
                    .into(),
                _ => todo!(),
            })
            .collect::<Vec<_>>()
            .into();

        node!(f => node)
    }
}

impl Format for ast::TrailingExtras {
    fn format(&self, f: &FormatConfig) -> Node {
        let mut prev_newline = false;
        node!(
            self.0
                .iter()
                .map(|extra| match &extra {
                    ast::ItemExtra::Comment(comment) => {
                        let node = comment.format(f);
                        prev_newline = node.ends_with_hardline();
                        node
                    }
                    ast::ItemExtra::Whitespace(ws) => ws
                        .chars()
                        .filter_map(|c| {
                            if c == '\n' {
                                Some(Node::Hardline)
                            } else {
                                None
                            }
                        })
                        .skip(if prev_newline { 1 } else { 0 })
                        .take(2) // Two white spaces maximum
                        .collect::<Vec<_>>()
                        .into(),
                    _ => todo!(),
                })
                .collect::<Vec<_>>()
        )
    }
}

pub(crate) fn with_extras(
    extras: &ast::ItemExtras,
    f: &FormatConfig,
    node: impl Into<Node>,
) -> Node {
    node!(f =>
        extras.leading
        node.into()
        extras.trailing
    )
}