rbfmt 0.0.2

Ruby code 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

use crate::fmt;

impl<'src> super::Parser<'src> {
    pub(super) fn parse_statements(
        &mut self,
        node: prism::StatementsNode,
        trailing_end: Option<usize>,
    ) -> fmt::Node {
        let statements = self.parse_statements_body(Some(node), trailing_end);
        let kind = fmt::Kind::Statements(statements);
        fmt::Node::new(kind)
    }

    pub(super) fn parse_statements_body(
        &mut self,
        node: Option<prism::StatementsNode>,
        end: Option<usize>,
    ) -> fmt::Statements {
        let mut statements = fmt::Statements::new();
        if let Some(node) = node {
            Self::each_node_with_trailing_end(node.body().iter(), end, |node, trailing_end| {
                let fmt_node = self.parse(node, trailing_end);
                statements.append_node(fmt_node);
            });
        }
        let virtual_end = self.take_end_trivia_as_virtual_end(end);
        statements.set_virtual_end(virtual_end);
        statements
    }

    pub(super) fn parse_parentheses(&mut self, node: prism::ParenthesesNode) -> fmt::Node {
        let closing_start = node.closing_loc().start_offset();
        let body = node.body().map(|b| self.parse(b, Some(closing_start)));
        let body = self.wrap_as_statements(body, closing_start);
        let parens = fmt::Parens::new(body);
        fmt::Node::new(fmt::Kind::Parens(parens))
    }

    pub(super) fn wrap_as_statements(
        &mut self,
        node: Option<fmt::Node>,
        end: usize,
    ) -> fmt::Statements {
        let (mut statements, should_take_end_trivia) = match node {
            None => (fmt::Statements::new(), true),
            Some(node) => match node.kind {
                fmt::Kind::Statements(statements) => (statements, false),
                _ => {
                    let mut statements = fmt::Statements::new();
                    statements.append_node(node);
                    (statements, true)
                }
            },
        };
        if should_take_end_trivia {
            let virtual_end = self.take_end_trivia_as_virtual_end(Some(end));
            statements.set_virtual_end(virtual_end);
        }
        statements
    }
}