twine-macros 0.4.2

Macros for Twine, a Rust framework for functional and composable system modeling.
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

use heck::ToUpperCamelCase;
use quote::format_ident;
use syn::Ident;

/// Extension trait for `Ident` to simplify common naming transformations.
#[allow(dead_code)]
pub(crate) trait IdentExt {
    /// Returns a new identifier in `UpperCamelCase`.
    fn upper_camel_case(&self) -> Ident;

    /// Returns a new identifier with the given prefix.
    fn with_prefix(&self, prefix: &str) -> Ident;

    /// Returns a new identifier with the given suffix.
    fn with_suffix(&self, suffix: &str) -> Ident;
}

impl IdentExt for Ident {
    fn upper_camel_case(&self) -> Ident {
        format_ident!("{}", self.to_string().to_upper_camel_case())
    }

    fn with_prefix(&self, prefix: &str) -> Ident {
        format_ident!("{}{}", prefix, self.to_string())
    }

    fn with_suffix(&self, suffix: &str) -> Ident {
        format_ident!("{}{}", self.to_string(), suffix)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use quote::format_ident;

    fn ident(name: &str) -> Ident {
        format_ident!("{}", name)
    }

    #[test]
    fn upper_camel_case_works() {
        assert_eq!(ident("single").upper_camel_case(), ident("Single"));
        assert_eq!(
            ident("example_name").upper_camel_case(),
            ident("ExampleName")
        );
        assert_eq!(
            ident("another_test_case").upper_camel_case(),
            ident("AnotherTestCase")
        );
        assert_eq!(
            ident("PascalCaseAlready").upper_camel_case(),
            ident("PascalCaseAlready")
        );
    }

    #[test]
    fn with_prefix_works() {
        assert_eq!(ident("example").with_prefix("test_"), ident("test_example"));
        assert_eq!(ident("FooBar").with_prefix("Test"), ident("TestFooBar"));
    }

    #[test]
    fn with_suffix_works() {
        assert_eq!(ident("example").with_suffix("_test"), ident("example_test"));
        assert_eq!(ident("FooBar").with_suffix("Test"), ident("FooBarTest"));
    }

    #[test]
    fn chaining_works() {
        assert_eq!(
            ident("example")
                .upper_camel_case()
                .with_prefix("Test")
                .with_suffix("Outputs"),
            ident("TestExampleOutputs")
        );
        assert_eq!(
            ident("the_model").upper_camel_case().with_suffix("Outputs"),
            ident("TheModelOutputs")
        );
        assert_eq!(
            ident("my_components")
                .with_prefix("all_")
                .with_suffix("_as_inputs")
                .upper_camel_case(),
            ident("AllMyComponentsAsInputs")
        );
    }
}