chartlet 0.22.0

Compile structured data into deterministic, accessible static charts
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

//! The text alternative and the data table: every message in order, with the fragments it is
//! in.

use std::fmt::Write as _;

use super::sequence;
use crate::{
    DataTable,
    spec::{ChartSpec, FragmentSpec, Locale, SequenceSpec},
    text,
};

/// The diagram in sentences: its participants, then every message in order, then the fragments.
pub(crate) fn description(spec: &ChartSpec) -> String {
    let sequence = sequence(spec);
    let locale = spec.locale;
    let participants: Vec<String> = sequence
        .participants
        .iter()
        .map(|participant| text::participant(locale, &participant.label, participant.kind))
        .collect();
    let mut description = text::sequence_opening(locale, &participants, sequence.messages.len());
    for (index, (message, (from, to))) in sequence.messages.iter().zip(sequence.ends()).enumerate()
    {
        let sender = &sequence.participants[from].label;
        let receiver = (from != to).then(|| sequence.participants[to].label.as_str());
        write!(
            description,
            " {}",
            text::sequence_message(
                locale,
                index + 1,
                sender,
                receiver,
                &message.label,
                message.kind
            )
        )
        .expect("writing to String cannot fail");
    }
    for fragment in &sequence.fragments {
        description.push(' ');
        description.push_str(&text::fragment(locale, fragment));
    }
    description
}

/// One row per message: its number, sender, receiver, label and kind, and the fragments around
/// it when the diagram has any.
pub(crate) fn data_table(spec: &ChartSpec) -> DataTable {
    let sequence = sequence(spec);
    let words = spec.locale.words();
    let mut columns: Vec<String> = [
        words.number,
        words.sender,
        words.receiver,
        words.message,
        words.message_kind,
    ]
    .iter()
    .map(|word| (*word).to_owned())
    .collect();
    let framed = !sequence.fragments.is_empty();
    if framed {
        columns.push(words.fragment.to_owned());
    }
    let rows = sequence
        .messages
        .iter()
        .zip(sequence.ends())
        .enumerate()
        .map(|(index, (message, (from, to)))| {
            let mut row = vec![
                (index + 1).to_string(),
                sequence.participants[from].label.clone(),
                sequence.participants[to].label.clone(),
                message.label.clone(),
                text::message_kind(spec.locale, message.kind).to_owned(),
            ];
            if framed {
                row.push(fragments_at(spec.locale, sequence, index));
            }
            row
        })
        .collect();
    DataTable {
        caption: format!("{} {}", words.data_for, spec.title),
        columns,
        rows,
    }
}

/// The fragments around message `index`, outermost first, each as its kind and the label of the
/// branch the message is in.
fn fragments_at(locale: Locale, sequence: &SequenceSpec, index: usize) -> String {
    let mut around: Vec<(usize, &FragmentSpec)> = sequence
        .fragments
        .iter()
        .enumerate()
        .filter(|(_, fragment)| fragment.from <= index && index <= fragment.to)
        .map(|(position, fragment)| (sequence.depth(position), fragment))
        .collect();
    crate::sort::by_key(&mut around, |(depth, _)| *depth);
    around
        .iter()
        .map(|(_, fragment)| {
            let label = fragment
                .branches
                .iter()
                .rev()
                .find(|branch| branch.from <= index)
                .map_or(fragment.label.as_deref(), |branch| {
                    Some(branch.label.as_deref().unwrap_or(text::otherwise(locale)))
                });
            match label {
                Some(label) => format!("{} [{label}]", fragment.kind.keyword()),
                None => fragment.kind.keyword().to_owned(),
            }
        })
        .collect::<Vec<_>>()
        .join(", ")
}