getargs-derive-macros 0.1.0

Internal implementation detail of getargs-derive. Not meant for direct use; depend on getargs-derive instead.
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

use crate::model::{FieldKind, FieldModel};

pub(super) const ARGUMENTS: &str = "Arguments";
pub(super) const OPTIONS: &str = "Options";

pub(super) struct Section<'a> {
    pub(super) title: &'a str,
    pub(super) fields: Vec<&'a FieldModel>,
}

pub(super) fn sections(fields: &[FieldModel]) -> Vec<Section<'_>> {
    let mut sections: Vec<(Section, Vec<usize>)> = [ARGUMENTS, OPTIONS]
        .into_iter()
        .map(|title| {
            (
                Section {
                    title,
                    fields: Vec::new(),
                },
                Vec::new(),
            )
        })
        .collect();

    for (index, field) in fields.iter().enumerate().filter(|(_, field)| !field.hide) {
        let title = field.help_heading.as_deref().unwrap_or(match field.kind {
            FieldKind::Positional => ARGUMENTS,
            FieldKind::Flag(_) | FieldKind::Option => OPTIONS,
        });
        let position = match sections
            .iter()
            .position(|(section, _)| section.title == title)
        {
            Some(position) => position,
            None => {
                sections.push((
                    Section {
                        title,
                        fields: Vec::new(),
                    },
                    Vec::new(),
                ));
                sections.len() - 1
            }
        };
        let (section, orders) = &mut sections[position];
        section.fields.push(field);
        orders.push(field.display_order.unwrap_or(index));
    }

    sections
        .into_iter()
        .map(|(section, orders)| {
            let mut keyed: Vec<_> = orders.into_iter().zip(section.fields).collect();
            keyed.sort_by_key(|(order, _)| *order);
            Section {
                title: section.title,
                fields: keyed.into_iter().map(|(_, field)| field).collect(),
            }
        })
        .collect()
}