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

#![doc = include_str!("crate-doc.md")]

use itertools::join;
use linkme::distributed_slice;
use std::cmp::Ordering;

#[doc(hidden)]
pub use linkme;

pub use ffizz_macros::item;
pub use ffizz_macros::snippet;

/// A HeaderItem contains an item that should be included in the output C header.
///
/// Only the `content` field will actually appear, with the other fields used to ensure a stable
/// order for the items.  `order` is used for coarse-grained ordering, such as putting introductory
/// comments at the top.  For items with equal `order`, `name` is used to sort.
#[doc(hidden)]
#[derive(Clone)]
pub struct HeaderItem {
    pub order: usize,
    pub name: &'static str,
    pub content: &'static str,
}

/// FFIZZ_HEADER_ITEMS collects HeaderItems using `linkme`.
#[doc(hidden)]
#[distributed_slice]
pub static FFIZZ_HEADER_ITEMS: [HeaderItem] = [..];

/// Generate the C header for the library.
///
/// This "magically" concatenates all of the header chunks supplied by `item` and `snippet` macro
/// invocations throughout all crates used to build the library.
pub fn generate() -> String {
    generate_from_vec(FFIZZ_HEADER_ITEMS.iter().collect::<Vec<_>>())
}

/// Inner version of generate that does not operate on a static value.
fn generate_from_vec(mut items: Vec<&'static HeaderItem>) -> String {
    items.sort_by(
        |a: &&'static HeaderItem, b: &&'static HeaderItem| match a.order.cmp(&b.order) {
            Ordering::Less => Ordering::Less,
            Ordering::Equal => a.name.cmp(b.name),
            Ordering::Greater => Ordering::Greater,
        },
    );

    // join the items with blank lines
    let mut result = join(items.iter().map(|hi| hi.content.trim()), "\n\n");
    // and ensure a trailing newline
    if !items.is_empty() {
        result.push('\n');
    }
    result
}

#[cfg(test)]
mod test {
    #[test]
    fn test_generate_order_by_order() {
        assert_eq!(
            super::generate_from_vec(vec![
                &super::HeaderItem {
                    order: 1,
                    name: "foo",
                    content: "one"
                },
                &super::HeaderItem {
                    order: 3,
                    name: "foo",
                    content: "three"
                },
                &super::HeaderItem {
                    order: 2,
                    name: "foo",
                    content: "two"
                },
            ]),
            String::from("one\n\ntwo\n\nthree\n")
        );
    }

    #[test]
    fn test_generate_order_by_name() {
        assert_eq!(
            super::generate_from_vec(vec![
                &super::HeaderItem {
                    order: 3,
                    name: "bbb",
                    content: "two"
                },
                &super::HeaderItem {
                    order: 3,
                    name: "ccc",
                    content: "three"
                },
                &super::HeaderItem {
                    order: 3,
                    name: "aaa",
                    content: "one"
                },
            ]),
            String::from("one\n\ntwo\n\nthree\n")
        );
    }

    #[test]
    fn test_empty() {
        assert_eq!(super::generate(), String::new());
    }
}