atelier_core 0.2.22

Rust native core model for the AWS Smithy IDL.
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

use std::collections::{HashMap, HashSet};

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Private Types
// ------------------------------------------------------------------------------------------------

lazy_static! {
    static ref UNWELCOME: HashSet<&'static str> =
        ["blacklist", "kill", "master", "slave", "whitelist"]
            .iter()
            .copied()
            .collect();
    static ref SYNONYMS: HashMap<&'static str, HashSet<&'static str>> = [
        (
            "noun:list",
            ["list", "bag", "queue"].iter().copied().collect()
        ),
        (
            "noun:map",
            ["map", "dictionary", "hash"].iter().copied().collect()
        ),
        (
            "noun:structure",
            ["structure", "document", "message", "record", "table"]
                .iter()
                .copied()
                .collect()
        ),
        ("noun:service", ["service", "svc"].iter().copied().collect()),
        (
            "noun:operation",
            ["operation", "function", "lambda", "procedure"]
                .iter()
                .copied()
                .collect()
        ),
        ("noun:input", ["input", "request"].iter().copied().collect()),
        (
            "noun:output",
            ["output", "response"].iter().copied().collect()
        ),
        (
            "noun:error",
            ["error", "exception", "failure"].iter().copied().collect()
        ),
        ("verb:create", ["create", "post"].iter().copied().collect()),
        ("verb:put", ["put", "push", "set"].iter().copied().collect()),
        (
            "verb:read",
            ["read", "fetch", "get", "retrieve"]
                .iter()
                .copied()
                .collect()
        ),
        ("verb:update", ["update", "post"].iter().copied().collect()),
        (
            "verb:delete",
            ["delete", "remove"].iter().copied().collect()
        ),
        ("verb:list", ["list", "post"].iter().copied().collect()),
    ]
    .iter()
    .cloned()
    .collect();
}

// ------------------------------------------------------------------------------------------------
// Public Functions
// ------------------------------------------------------------------------------------------------

// TODO: check synonyms in linters.
// (https://github.com/johnstonskj/rust-atelier/issues/6)

#[inline]
pub(crate) fn is_unwelcome_term(term: &str) -> bool {
    UNWELCOME.contains(term)
}

#[allow(dead_code)]
#[inline]
pub(crate) fn is_synonym(term: &str, expect: &str) -> bool {
    match UNWELCOME.get(expect) {
        None => term.ends_with(&format!(":{}", expect)),
        Some(syns) => syns.contains(term),
    }
}

#[allow(dead_code)]
#[inline]
pub(crate) fn is_not_synonym(term: &str, expect: &[&str]) -> bool {
    expect.iter().all(|e| !is_synonym(term, e))
}

#[allow(dead_code)]
pub(crate) fn synonyms(term: &str) -> Option<&HashSet<&'static str>> {
    SYNONYMS.get(term)
}

pub(crate) fn split_words(s: &str) -> Vec<String> {
    use heck::SnakeCase;
    s.to_snake_case().split('_').map(str::to_string).collect()
}

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Private Functions
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Modules
// ------------------------------------------------------------------------------------------------