gearbox 3.0.0

Excessive tooling for Rust, boosting productivity and operations
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

pub mod header;
pub mod response;
pub mod status_code;
pub mod url;

use header::HeaderMap;
use serde_derive::{Deserialize, Serialize};
use std::collections::HashMap;

pub struct ApiLayout {
    pub group_description: Option<String>,
    pub servers: Vec<url::Url>,
    pub endpoints: HashMap<String, MethodLayout>,
}

pub enum MethodLayout {
    Get(GetLayout),
    Post(PostLayout),
    Put(PutLayout),
    Delete(DeleteLayout),
    Patch(PatchLayout),
    Options(OptionsLayout),
    Head(HeadLayout),
    Connect(ConnectLayout),
    Trace(TraceLayout),
}

pub struct GetLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: RequestContent,
    pub responses: ExpectedResponses,
}

pub struct PostLayout {
    pub singleuse: bool,
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: RequestContent,
    pub responses: ExpectedResponses,
}

pub struct PutLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: RequestContent,
    pub responses: ExpectedResponses,
}

pub struct DeleteLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: Option<RequestContent>,
    pub responses: ExpectedResponses,
}

pub struct PatchLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: RequestContent,
    pub responses: ExpectedResponses,
}

pub struct OptionsLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub responses: ExpectedResponses,
}

pub struct HeadLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub responses: ExpectedResponses,
}

pub struct ConnectLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: RequestContent,
    pub responses: ExpectedResponses,
}

pub struct TraceLayout {
    pub description: Option<String>,
    pub headers: HeaderMap,
    pub request: RequestContent,
    pub responses: ExpectedResponses,
}

pub struct RequestContent {
    pub content: HashMap<String, Schema>,
}

pub enum Schema {
    String,
    Properties(Properties),
    Array(Vec<Schema>),
    Object(HashMap<String, Schema>),
    Boolean,
    Number,
    Integer,
    Null,
}

pub struct Properties {
    pub fields: HashMap<String, PropertyType>,
}

pub struct PropertyType {
    pub r#type: String,
}

/// Matches parts of a response for variable capturing.
#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
#[derive(Clone, Debug, Serialize, Deserialize, Default)]
pub struct Matcher {
    #[serde(skip_serializing_if = "Option::is_none")]
    between: Option<(String, String)>,
    #[serde(skip_serializing_if = "Option::is_none")]
    regexp: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    xpath: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    all: Option<bool>,
}

#[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
impl Matcher {
    /// Creates a matcher for capturing text between two strings.
    pub fn between(from: String, to: String) -> Matcher {
        Matcher {
            between: Some((from, to)),
            regexp: None,
            xpath: None,
            all: None,
        }
    }

    /// Creates a matcher for capturing text using a regular expression.
    pub fn regexp(regexp: String) -> Matcher {
        Matcher {
            between: None,
            regexp: Some(regexp),
            xpath: None,
            all: None,
        }
    }

    /// Creates a matcher for capturing all text.
    pub fn all(all: bool) -> Matcher {
        Matcher {
            between: None,
            regexp: None,
            all: Some(all),
            xpath: None,
        }
    }
}