wdl-format 0.18.0

Formatting of WDL (Workflow Description Language) documents
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Formatting for enums.

use wdl_ast::SyntaxKind;

use crate::Config;
use crate::PreToken;
use crate::TokenStream;
use crate::Writable as _;
use crate::element::FormatElement;

/// Formats an [`EnumDefinition`](wdl_ast::v1::EnumDefinition).
///
/// # Panics
///
/// This will panic if the element does not have the expected children.
pub fn format_enum_definition(
    element: &FormatElement,
    stream: &mut TokenStream<PreToken>,
    config: &Config,
) {
    let mut children = element.children().expect("enum definition children");

    let enum_keyword = children.next().expect("enum keyword");
    assert!(enum_keyword.element().kind() == SyntaxKind::EnumKeyword);
    (&enum_keyword).write(stream, config);
    stream.end_word();

    let name = children.next().expect("enum name");
    assert!(name.element().kind() == SyntaxKind::Ident);
    (&name).write(stream, config);

    let mut variants = Vec::new();
    let mut commas = Vec::new();
    let mut close_brace = None;

    for child in children {
        match child.element().kind() {
            SyntaxKind::EnumTypeParameterNode => {
                (&child).write(stream, config);
            }
            SyntaxKind::OpenBrace => {
                stream.end_word();
                (&child).write(stream, config);
                stream.end_line();
                stream.increment_indent();
            }
            SyntaxKind::EnumVariantNode => {
                variants.push(child.clone());
            }
            SyntaxKind::Comma => {
                commas.push(child.clone());
            }
            SyntaxKind::CloseBrace => {
                close_brace = Some(child.clone());
            }
            _ => {
                unreachable!(
                    "unexpected child in enum definition: {:?}",
                    child.element().kind()
                );
            }
        }
    }

    let mut commas = commas.iter();
    for variant in variants {
        (&variant).write(stream, config);
        if let Some(comma) = commas.next() {
            (comma).write(stream, config);
        } else if config.trailing_commas {
            stream.push_literal(",".to_string(), SyntaxKind::Comma);
        }
        stream.end_line();
    }

    stream.decrement_indent();
    (&close_brace.expect("enum definition close brace")).write(stream, config);
    stream.end_line();
}

/// Formats an [`EnumVariant`](wdl_ast::v1::EnumVariant).
///
/// # Panics
///
/// This will panic if the element does not have the expected children.
pub fn format_enum_variant(
    element: &FormatElement,
    stream: &mut TokenStream<PreToken>,
    config: &Config,
) {
    let mut children = element.children().expect("enum variant children");

    let name = children.next().expect("enum variant name");
    assert!(name.element().kind() == SyntaxKind::Ident);
    (&name).write(stream, config);

    for child in children {
        match child.element().kind() {
            SyntaxKind::Assignment => {
                stream.end_word();
                (&child).write(stream, config);
                stream.end_word();
            }
            _ => {
                (&child).write(stream, config);
            }
        }
    }
}

/// Formats an [`EnumTypeParameter`](wdl_ast::v1::EnumTypeParameter).
///
/// # Panics
///
/// This will panic if the element does not have the expected children.
pub fn format_enum_type_parameter(
    element: &FormatElement,
    stream: &mut TokenStream<PreToken>,
    config: &Config,
) {
    for child in element.children().expect("enum type parameter children") {
        (&child).write(stream, config);
    }
}