shuck-formatter 0.0.43

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use rustc_hash::FxHashMap as HashMap;

use shuck_ast::{CompoundCommand, Span};

use super::FactSpan;

#[derive(Debug, Clone, Default)]
pub(super) struct CompoundFacts {
    close_spans: HashMap<FactSpan, Span>,
}

impl CompoundFacts {
    pub(super) fn key(command: &CompoundCommand) -> Option<FactSpan> {
        compound_close_key(command)
    }

    pub(super) fn close_span(&self, command: &CompoundCommand) -> Option<Span> {
        Self::key(command).and_then(|key| self.close_span_for_key(key))
    }

    pub(super) fn close_span_for_span(&self, span: Span) -> Option<Span> {
        self.close_spans.get(&FactSpan::from(span)).copied()
    }

    pub(super) fn close_span_for_key(&self, key: FactSpan) -> Option<Span> {
        self.close_spans.get(&key).copied()
    }

    pub(super) fn insert_close_span(&mut self, key: FactSpan, span: Span) {
        self.close_spans.insert(key, span);
    }

    #[cfg(feature = "benchmarking")]
    pub(super) fn len(&self) -> usize {
        self.close_spans.len()
    }
}

fn compound_close_key(command: &CompoundCommand) -> Option<FactSpan> {
    let span = match command {
        CompoundCommand::If(command) => command.span,
        CompoundCommand::For(command) => match command.syntax {
            shuck_ast::ForSyntax::InDoDone { .. }
            | shuck_ast::ForSyntax::ParenDoDone { .. }
            | shuck_ast::ForSyntax::InBrace { .. }
            | shuck_ast::ForSyntax::ParenBrace { .. } => command.span,
            shuck_ast::ForSyntax::InDirect { .. } | shuck_ast::ForSyntax::ParenDirect { .. } => {
                return None;
            }
        },
        CompoundCommand::Repeat(command) => match command.syntax {
            shuck_ast::RepeatSyntax::DoDone { .. } | shuck_ast::RepeatSyntax::Brace { .. } => {
                command.span
            }
            shuck_ast::RepeatSyntax::Direct => return None,
        },
        CompoundCommand::Foreach(command) => match command.syntax {
            shuck_ast::ForeachSyntax::InDoDone { .. }
            | shuck_ast::ForeachSyntax::ParenBrace { .. } => command.span,
        },
        CompoundCommand::ArithmeticFor(command) => command.span,
        CompoundCommand::While(command) => command.span,
        CompoundCommand::Until(command) => command.span,
        CompoundCommand::Case(command) => command.span,
        CompoundCommand::Select(command) => command.span,
        CompoundCommand::Subshell(_)
        | CompoundCommand::BraceGroup(_)
        | CompoundCommand::Arithmetic(_)
        | CompoundCommand::Time(_)
        | CompoundCommand::Conditional(_)
        | CompoundCommand::Coproc(_)
        | CompoundCommand::Always(_) => return None,
    };
    Some(FactSpan::from(span))
}