shuck-formatter 0.1.1

Shell script formatter with configurable style options
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

use super::*;

pub(super) enum CompoundChild<'a> {
    Stmt(&'a Stmt),
    Sequence(&'a StmtSeq),
}

pub(super) fn for_each_compound_child(
    command: &CompoundCommand,
    mut visitor: impl FnMut(CompoundChild<'_>),
) {
    match command {
        CompoundCommand::If(command) => {
            visitor(CompoundChild::Sequence(&command.condition));
            visitor(CompoundChild::Sequence(&command.then_branch));
            for (condition, body) in &command.elif_branches {
                visitor(CompoundChild::Sequence(condition));
                visitor(CompoundChild::Sequence(body));
            }
            if let Some(body) = &command.else_branch {
                visitor(CompoundChild::Sequence(body));
            }
        }
        CompoundCommand::For(command) => visitor(CompoundChild::Sequence(&command.body)),
        CompoundCommand::Repeat(command) => visitor(CompoundChild::Sequence(&command.body)),
        CompoundCommand::Foreach(command) => visitor(CompoundChild::Sequence(&command.body)),
        CompoundCommand::ArithmeticFor(command) => visitor(CompoundChild::Sequence(&command.body)),
        CompoundCommand::While(command) => {
            visitor(CompoundChild::Sequence(&command.condition));
            visitor(CompoundChild::Sequence(&command.body));
        }
        CompoundCommand::Until(command) => {
            visitor(CompoundChild::Sequence(&command.condition));
            visitor(CompoundChild::Sequence(&command.body));
        }
        CompoundCommand::Case(command) => {
            for item in &command.cases {
                visitor(CompoundChild::Sequence(&item.body));
            }
        }
        CompoundCommand::Select(command) => visitor(CompoundChild::Sequence(&command.body)),
        CompoundCommand::Subshell(commands) | CompoundCommand::BraceGroup(commands) => {
            visitor(CompoundChild::Sequence(commands));
        }
        CompoundCommand::Arithmetic(_) | CompoundCommand::Conditional(_) => {}
        CompoundCommand::Time(command) => {
            if let Some(command) = command.command.as_deref() {
                visitor(CompoundChild::Stmt(command));
            }
        }
        CompoundCommand::Coproc(command) => visitor(CompoundChild::Stmt(&command.body)),
        CompoundCommand::Always(command) => {
            visitor(CompoundChild::Sequence(&command.body));
            visitor(CompoundChild::Sequence(&command.always_body));
        }
    }
}