1mod csv;
2pub mod fmt_meta;
3mod formatter;
4mod json;
5mod kv;
6mod proto;
7mod raw;
8mod sql;
9
10pub use csv::Csv;
11pub use formatter::{DataFormat, StaticDataFormatter};
12pub use json::Json;
13pub use kv::KeyValue;
14pub use proto::ProtoTxt;
15pub use raw::Raw;
16pub use sql::SqlInsert;
17
18use wp_model_core::model::fmt_def::TextFmt;
19
20pub enum FormatType {
21 Json(Json),
22 Csv(Csv),
23 Kv(KeyValue),
24 Sql(SqlInsert),
25 Raw(Raw),
26 ProtoText(ProtoTxt),
27}
28
29impl From<&TextFmt> for FormatType {
30 fn from(fmt: &TextFmt) -> Self {
31 match fmt {
32 TextFmt::Json => FormatType::Json(Json),
33 TextFmt::Csv => FormatType::Csv(Csv::default()),
34 TextFmt::Kv => FormatType::Kv(KeyValue::default()),
35 TextFmt::Raw => FormatType::Raw(Raw),
36 TextFmt::ProtoText => FormatType::ProtoText(ProtoTxt),
37 TextFmt::Show => FormatType::Raw(Raw),
38 TextFmt::Proto => FormatType::ProtoText(ProtoTxt),
39 }
40 }
41}
42
43pub enum SqlFormat {
44 Json(Json),
45 Kv(KeyValue),
46 Raw(Raw),
47 ProtoText(ProtoTxt),
48}
49
50impl From<&TextFmt> for SqlFormat {
51 fn from(fmt: &TextFmt) -> Self {
52 match fmt {
53 TextFmt::Json => SqlFormat::Json(Json),
54 TextFmt::Kv => SqlFormat::Kv(KeyValue::default()),
55 TextFmt::Raw => SqlFormat::Raw(Raw),
56 TextFmt::ProtoText => SqlFormat::ProtoText(ProtoTxt),
57 _ => SqlFormat::Raw(Raw),
58 }
59 }
60}
61
62#[cfg(test)]
63mod tests {
64 use super::*;
65 use formatter::DataFormat;
66 use wp_model_core::model::{DataField, DataRecord};
67
68 #[test]
69 fn test_format_type_from_text_fmt_json() {
70 let fmt = FormatType::from(&TextFmt::Json);
71 matches!(fmt, FormatType::Json(_));
72 }
73
74 #[test]
75 fn test_format_type_from_text_fmt_csv() {
76 let fmt = FormatType::from(&TextFmt::Csv);
77 matches!(fmt, FormatType::Csv(_));
78 }
79
80 #[test]
81 fn test_format_type_from_text_fmt_kv() {
82 let fmt = FormatType::from(&TextFmt::Kv);
83 matches!(fmt, FormatType::Kv(_));
84 }
85
86 #[test]
87 fn test_format_type_from_text_fmt_raw() {
88 let fmt = FormatType::from(&TextFmt::Raw);
89 matches!(fmt, FormatType::Raw(_));
90 }
91
92 #[test]
93 fn test_format_type_from_text_fmt_proto_text() {
94 let fmt = FormatType::from(&TextFmt::ProtoText);
95 matches!(fmt, FormatType::ProtoText(_));
96 }
97
98 #[test]
99 fn test_format_type_from_text_fmt_show() {
100 let fmt = FormatType::from(&TextFmt::Show);
101 matches!(fmt, FormatType::Raw(_));
102 }
103
104 #[test]
105 fn test_format_type_from_text_fmt_proto() {
106 let fmt = FormatType::from(&TextFmt::Proto);
107 matches!(fmt, FormatType::ProtoText(_));
108 }
109
110 #[test]
111 fn test_sql_format_from_text_fmt_json() {
112 let fmt = SqlFormat::from(&TextFmt::Json);
113 matches!(fmt, SqlFormat::Json(_));
114 }
115
116 #[test]
117 fn test_sql_format_from_text_fmt_kv() {
118 let fmt = SqlFormat::from(&TextFmt::Kv);
119 matches!(fmt, SqlFormat::Kv(_));
120 }
121
122 #[test]
123 fn test_sql_format_from_text_fmt_raw() {
124 let fmt = SqlFormat::from(&TextFmt::Raw);
125 matches!(fmt, SqlFormat::Raw(_));
126 }
127
128 #[test]
129 fn test_sql_format_from_text_fmt_proto_text() {
130 let fmt = SqlFormat::from(&TextFmt::ProtoText);
131 matches!(fmt, SqlFormat::ProtoText(_));
132 }
133
134 #[test]
135 fn test_sql_format_from_text_fmt_csv_fallback() {
136 let fmt = SqlFormat::from(&TextFmt::Csv);
138 matches!(fmt, SqlFormat::Raw(_));
139 }
140
141 #[test]
142 fn test_format_type_dataformat_null() {
143 let fmt = FormatType::from(&TextFmt::Json);
144 assert_eq!(fmt.format_null(), "null");
145
146 let fmt = FormatType::from(&TextFmt::Csv);
147 assert_eq!(fmt.format_null(), "");
148
149 let fmt = FormatType::from(&TextFmt::Raw);
150 assert_eq!(fmt.format_null(), "");
151 }
152
153 #[test]
154 fn test_format_type_dataformat_bool() {
155 let fmt = FormatType::from(&TextFmt::Json);
156 assert_eq!(fmt.format_bool(&true), "true");
157 assert_eq!(fmt.format_bool(&false), "false");
158 }
159
160 #[test]
161 fn test_format_type_dataformat_string() {
162 let json_fmt = FormatType::from(&TextFmt::Json);
163 assert_eq!(json_fmt.format_string("hello"), "\"hello\"");
164
165 let raw_fmt = FormatType::from(&TextFmt::Raw);
166 assert_eq!(raw_fmt.format_string("hello"), "hello");
167 }
168
169 #[test]
170 fn test_format_type_dataformat_i64() {
171 let fmt = FormatType::from(&TextFmt::Json);
172 assert_eq!(fmt.format_i64(&42), "42");
173 assert_eq!(fmt.format_i64(&-100), "-100");
174 }
175
176 #[test]
177 fn test_format_type_dataformat_f64() {
178 let fmt = FormatType::from(&TextFmt::Json);
179 assert_eq!(fmt.format_f64(&3.24), "3.24");
180 }
181
182 #[test]
183 fn test_format_type_format_record() {
184 let json_fmt = FormatType::from(&TextFmt::Json);
185 let record = DataRecord {
186 items: vec![
187 DataField::from_chars("name", "Alice"),
188 DataField::from_digit("age", 30),
189 ],
190 };
191 let result = json_fmt.format_record(&record);
192 assert!(result.starts_with('{'));
193 assert!(result.ends_with('}'));
194 assert!(result.contains("\"name\":\"Alice\""));
195 }
196
197 #[test]
198 fn test_format_type_format_field() {
199 let fmt = FormatType::from(&TextFmt::Json);
200 let field = DataField::from_chars("key", "value");
201 let result = fmt.format_field(&field);
202 assert!(result.contains("key"));
203 assert!(result.contains("value"));
204 }
205
206 #[test]
207 fn test_csv_format_type() {
208 let csv_fmt = FormatType::from(&TextFmt::Csv);
209 let record = DataRecord {
210 items: vec![
211 DataField::from_chars("a", "x"),
212 DataField::from_chars("b", "y"),
213 ],
214 };
215 let result = csv_fmt.format_record(&record);
216 assert_eq!(result, "x,y");
217 }
218
219 #[test]
220 fn test_kv_format_type() {
221 let kv_fmt = FormatType::from(&TextFmt::Kv);
222 let record = DataRecord {
223 items: vec![DataField::from_chars("name", "Alice")],
224 };
225 let result = kv_fmt.format_record(&record);
226 assert!(result.contains("name"));
227 assert!(result.contains("Alice"));
228 }
229}