1use cmake_parser_derive::CMake;
2
3use crate::{
4 command::common::HashAlgorithm,
5 doc::command_scope::{CommandScope, ToCommandScope},
6 Token,
7};
8
9#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
13#[cmake(pkg = "crate", untagged)]
14pub enum String<'t> {
15 SearchAndReplace(StringSearchAndReplace<'t>),
16 Manipulation(StringManipulation<'t>),
17 Comparison(StringComparison<'t>),
18 Hash(StringHash<'t>),
19 Generation(StringGeneration<'t>),
20 #[cmake(transparent)]
21 Json(StringJson<'t>),
22}
23
24impl<'t> ToCommandScope for String<'t> {
25 fn to_command_scope(&self) -> CommandScope {
26 CommandScope::Scripting
27 }
28}
29
30#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
31#[cmake(pkg = "crate", untagged, transparent)]
32pub enum StringSearchAndReplace<'t> {
33 Find(StringFind<'t>),
34 Replace(StringReplace<'t>),
35 Regex(StringRegex<'t>),
36}
37
38#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
39#[cmake(pkg = "crate", positional)]
40pub struct StringFind<'t> {
41 pub string: Token<'t>,
42 pub substring: Token<'t>,
43 pub output_variable: Token<'t>,
44 pub reverse: bool,
45}
46
47#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
48#[cmake(pkg = "crate", positional)]
49pub struct StringReplace<'t> {
50 pub match_string: Token<'t>,
51 pub replace_string: Token<'t>,
52 pub output_variable: Token<'t>,
53 pub input: Vec<Token<'t>>,
54}
55
56#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
57#[cmake(pkg = "crate", untagged, transparent)]
58pub enum StringRegex<'t> {
59 Match(StringRegexMatch<'t>),
60 #[cmake(rename = "MATCHALL")]
61 MatchAll(StringRegexMatchAll<'t>),
62 Replace(StringRegexReplace<'t>),
63}
64
65#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
66#[cmake(pkg = "crate", positional)]
67pub struct StringRegexMatch<'t> {
68 pub regular_expression: Token<'t>,
69 pub output_variable: Token<'t>,
70 pub input: Vec<Token<'t>>,
71}
72
73#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
74#[cmake(pkg = "crate", positional)]
75pub struct StringRegexMatchAll<'t> {
76 pub regular_expression: Token<'t>,
77 pub output_variable: Token<'t>,
78 pub input: Vec<Token<'t>>,
79}
80
81#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
82#[cmake(pkg = "crate", positional)]
83pub struct StringRegexReplace<'t> {
84 pub regular_expression: Token<'t>,
85 pub replacement_expression: Token<'t>,
86 pub output_variable: Token<'t>,
87 pub input: Vec<Token<'t>>,
88}
89
90#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
91#[cmake(pkg = "crate", untagged, transparent)]
92pub enum StringManipulation<'t> {
93 Append(StringAppend<'t>),
94 Prepend(StringPrepend<'t>),
95 Concat(StringConcat<'t>),
96 Join(StringJoin<'t>),
97 #[cmake(rename = "TOLOWER")]
98 ToLower(StringToLower<'t>),
99 #[cmake(rename = "TOUPPER")]
100 ToUpper(StringToUpper<'t>),
101 Length(StringLength<'t>),
102 Substring(StringSubstring<'t>),
103 Strip(StringStrip<'t>),
104 GenexStrip(StringGenexStrip<'t>),
105 Repeat(StringRepeat<'t>),
106}
107
108#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
109#[cmake(pkg = "crate", positional)]
110pub struct StringAppend<'t> {
111 pub string_variable: Token<'t>,
112 pub input: Vec<Token<'t>>,
113}
114
115#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
116#[cmake(pkg = "crate", positional)]
117pub struct StringPrepend<'t> {
118 pub string_variable: Token<'t>,
119 pub input: Vec<Token<'t>>,
120}
121
122#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
123#[cmake(pkg = "crate", positional)]
124pub struct StringConcat<'t> {
125 pub output_variable: Token<'t>,
126 pub input: Vec<Token<'t>>,
127}
128
129#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
130#[cmake(pkg = "crate", positional)]
131pub struct StringJoin<'t> {
132 pub glue: Token<'t>,
133 pub output_variable: Token<'t>,
134 pub input: Vec<Token<'t>>,
135}
136
137#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
138#[cmake(pkg = "crate", positional)]
139pub struct StringToLower<'t> {
140 pub string: Token<'t>,
141 pub output_variable: Token<'t>,
142}
143
144#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
145#[cmake(pkg = "crate", positional)]
146pub struct StringToUpper<'t> {
147 pub string: Token<'t>,
148 pub output_variable: Token<'t>,
149}
150
151#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
152#[cmake(pkg = "crate", positional)]
153pub struct StringLength<'t> {
154 pub string: Token<'t>,
155 pub output_variable: Token<'t>,
156}
157
158#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
159#[cmake(pkg = "crate", positional)]
160pub struct StringSubstring<'t> {
161 pub string: Token<'t>,
162 pub begin: Token<'t>,
163 pub length: Token<'t>,
164 pub output_variable: Token<'t>,
165}
166
167#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
168#[cmake(pkg = "crate", positional)]
169pub struct StringStrip<'t> {
170 pub string: Token<'t>,
171 pub output_variable: Token<'t>,
172}
173
174#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
175#[cmake(pkg = "crate", positional)]
176pub struct StringGenexStrip<'t> {
177 pub string: Token<'t>,
178 pub output_variable: Token<'t>,
179}
180
181#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
182#[cmake(pkg = "crate", positional)]
183pub struct StringRepeat<'t> {
184 pub string: Token<'t>,
185 pub count: Token<'t>,
186 pub output_variable: Token<'t>,
187}
188
189#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
190#[cmake(pkg = "crate", untagged, transparent)]
191pub enum StringComparison<'t> {
192 Less(StringLess<'t>),
193 Greater(StringGreater<'t>),
194 Equal(StringEqual<'t>),
195 #[cmake(rename = "NOTEQUAL")]
196 NotEqual(StringNotEqual<'t>),
197 LessEqual(StringLessEqual<'t>),
198 GreaterEqual(StringGreaterEqual<'t>),
199}
200
201#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
202#[cmake(pkg = "crate", positional)]
203pub struct StringLess<'t> {
204 pub string1: Token<'t>,
205 pub string2: Token<'t>,
206 pub output_variable: Token<'t>,
207}
208
209#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
210#[cmake(pkg = "crate", positional)]
211pub struct StringGreater<'t> {
212 pub string1: Token<'t>,
213 pub string2: Token<'t>,
214 pub output_variable: Token<'t>,
215}
216
217#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
218#[cmake(pkg = "crate", positional)]
219pub struct StringEqual<'t> {
220 pub string1: Token<'t>,
221 pub string2: Token<'t>,
222 pub output_variable: Token<'t>,
223}
224
225#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
226#[cmake(pkg = "crate", positional)]
227pub struct StringNotEqual<'t> {
228 pub string1: Token<'t>,
229 pub string2: Token<'t>,
230 pub output_variable: Token<'t>,
231}
232
233#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
234#[cmake(pkg = "crate", positional)]
235pub struct StringLessEqual<'t> {
236 pub string1: Token<'t>,
237 pub string2: Token<'t>,
238 pub output_variable: Token<'t>,
239}
240
241#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
242#[cmake(pkg = "crate", positional)]
243pub struct StringGreaterEqual<'t> {
244 pub string1: Token<'t>,
245 pub string2: Token<'t>,
246 pub output_variable: Token<'t>,
247}
248
249#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
250#[cmake(pkg = "crate", positional)]
251pub struct StringHash<'t> {
252 pub hash_algorithm: HashAlgorithm,
253 pub output_variable: Token<'t>,
254 pub input: Token<'t>,
255}
256
257#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
258#[cmake(pkg = "crate", untagged, transparent)]
259pub enum StringGeneration<'t> {
260 Ascii(StringAscii<'t>),
261 Hex(StringHex<'t>),
262 Configure(StringConfigure<'t>),
263 #[cmake(rename = "MAKE_C_IDENTIFIER")]
264 MakeCIdentifier(StringMakeCIdentifier<'t>),
265 Random(StringRandom<'t>),
266 Timestamp(StringTimestamp<'t>),
267 Uuid(StringUuid<'t>),
268}
269
270#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
271#[cmake(pkg = "crate", positional)]
272pub struct StringAscii<'t> {
273 pub number: Vec<Token<'t>>,
274 #[cmake(last)]
275 pub output_variable: Token<'t>,
276}
277
278#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
279#[cmake(pkg = "crate", positional)]
280pub struct StringHex<'t> {
281 pub string: Token<'t>,
282 pub output_variable: Token<'t>,
283}
284
285#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
286#[cmake(pkg = "crate", positional)]
287pub struct StringConfigure<'t> {
288 pub string: Token<'t>,
289 pub output_variable: Token<'t>,
290 #[cmake(rename = "@ONLY")]
291 pub only: bool,
292 pub escape_quotes: bool,
293}
294
295#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
296#[cmake(pkg = "crate", positional)]
297pub struct StringMakeCIdentifier<'t> {
298 pub string: Token<'t>,
299 pub output_variable: Token<'t>,
300}
301
302#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
303#[cmake(pkg = "crate", default = "output_variable")]
304pub struct StringRandom<'t> {
305 pub length: Option<Token<'t>>,
306 pub alphabet: Option<Token<'t>>,
307 pub random_seed: Option<Token<'t>>,
308 #[cmake(rename = "")]
309 pub output_variable: Token<'t>,
310}
311
312#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
313#[cmake(pkg = "crate", positional)]
314pub struct StringTimestamp<'t> {
315 pub output_variable: Token<'t>,
316 #[cmake(allow_empty, in_range)]
317 pub format_string: Option<Token<'t>>,
318 pub utc: bool,
319}
320
321#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
322#[cmake(pkg = "crate", positional)]
323pub struct StringUuid<'t> {
324 pub output_variable: Token<'t>,
325 #[cmake(transparent)]
326 pub namespace: Token<'t>,
327 #[cmake(transparent)]
328 pub name: Token<'t>,
329 #[cmake(transparent, rename = "TYPE")]
330 pub hash_algorithm: UuidHashAlgorithm,
331 pub upper: bool,
332}
333
334#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
335#[cmake(pkg = "crate")]
336pub enum UuidHashAlgorithm {
337 MD5,
338 SHA1,
339}
340
341#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
342#[cmake(pkg = "crate", positional)]
343pub struct StringJson<'t> {
344 pub output_variable: Token<'t>,
345 #[cmake(transparent)]
346 pub error_variable: Option<Token<'t>>,
347 pub command: JsonCommand<'t>,
348}
349
350#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
351#[cmake(pkg = "crate", transparent)]
352pub enum JsonCommand<'t> {
353 Get(StringJsonGet<'t>),
354 Type(StringJsonType<'t>),
355 Member(StringJsonMember<'t>),
356 Length(StringJsonLength<'t>),
357 Remove(StringJsonRemove<'t>),
358 Set(StringJsonSet<'t>),
359 Equal(StringJsonEqual<'t>),
360}
361
362#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
363#[cmake(pkg = "crate", positional)]
364pub struct StringJsonGet<'t> {
365 pub json_string: Token<'t>,
366 pub member_index: Vec<Token<'t>>,
367}
368
369#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
370#[cmake(pkg = "crate", positional)]
371pub struct StringJsonType<'t> {
372 pub json_string: Token<'t>,
373 pub member_index: Vec<Token<'t>>,
374}
375
376#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
377#[cmake(pkg = "crate", positional)]
378pub struct StringJsonMember<'t> {
379 pub json_string: Token<'t>,
380 pub member_index: Option<Vec<Token<'t>>>,
381 #[cmake(last)]
382 pub index: Token<'t>,
383}
384
385#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
386#[cmake(pkg = "crate", positional)]
387pub struct StringJsonLength<'t> {
388 pub json_string: Token<'t>,
389 pub member_index: Option<Vec<Token<'t>>>,
390}
391
392#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
393#[cmake(pkg = "crate", positional)]
394pub struct StringJsonRemove<'t> {
395 pub json_string: Token<'t>,
396 pub member_index: Vec<Token<'t>>,
397}
398
399#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
400#[cmake(pkg = "crate", positional)]
401pub struct StringJsonSet<'t> {
402 pub json_string: Token<'t>,
403 pub member_index: Vec<Token<'t>>,
404 #[cmake(last)]
405 pub value: Token<'t>,
406}
407
408#[derive(CMake, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
409#[cmake(pkg = "crate", positional)]
410pub struct StringJsonEqual<'t> {
411 pub json_string1: Token<'t>,
412 pub json_string2: Token<'t>,
413}
414
415#[cfg(test)]
416mod tests {
417 use super::*;
418 use crate::doc::cmake_parse::tests::{token, tokens_vec};
419 use crate::*;
420 use pretty_assertions::assert_eq;
421
422 #[test]
423 fn string() {
424 let src = include_bytes!("../../../../../fixture/commands/scripting/string");
425 let cmakelists = parse_cmakelists(src).unwrap();
426 let doc = Doc::from(cmakelists);
427 assert_eq!(
428 doc.to_commands_iter().collect::<Vec<_>>(),
429 vec![
430 Ok(Command::String(Box::new(String::SearchAndReplace(
431 StringSearchAndReplace::Find(StringFind {
432 string: token(b"str1"),
433 substring: token(b"substr1"),
434 output_variable: token(b"out_var1"),
435 reverse: false,
436 })
437 )))),
438 Ok(Command::String(Box::new(String::SearchAndReplace(
439 StringSearchAndReplace::Find(StringFind {
440 string: token(b"str1"),
441 substring: token(b"substr1"),
442 output_variable: token(b"out_var1"),
443 reverse: true,
444 })
445 )))),
446 Ok(Command::String(Box::new(String::SearchAndReplace(
447 StringSearchAndReplace::Replace(StringReplace {
448 match_string: token(b"match_str1"),
449 replace_string: token(b"replace_str1"),
450 output_variable: token(b"out_var1"),
451 input: tokens_vec([b"input1", b"input2"]),
452 })
453 )))),
454 Ok(Command::String(Box::new(String::SearchAndReplace(
455 StringSearchAndReplace::Regex(StringRegex::Match(StringRegexMatch {
456 regular_expression: token(b"regex1"),
457 output_variable: token(b"out_var1"),
458 input: tokens_vec([b"input1", b"input2"]),
459 }))
460 )))),
461 Ok(Command::String(Box::new(String::SearchAndReplace(
462 StringSearchAndReplace::Regex(StringRegex::MatchAll(StringRegexMatchAll {
463 regular_expression: token(b"regex1"),
464 output_variable: token(b"out_var1"),
465 input: tokens_vec([b"input1", b"input2"]),
466 }))
467 )))),
468 Ok(Command::String(Box::new(String::SearchAndReplace(
469 StringSearchAndReplace::Regex(StringRegex::Replace(StringRegexReplace {
470 regular_expression: token(b"regex1"),
471 replacement_expression: token(b"replace_ex1"),
472 output_variable: token(b"out_var1"),
473 input: tokens_vec([b"input1", b"input2"]),
474 }))
475 )))),
476 Ok(Command::String(Box::new(String::Manipulation(
477 StringManipulation::Append(StringAppend {
478 string_variable: token(b"str_var1"),
479 input: tokens_vec([b"input1", b"input2"]),
480 })
481 )))),
482 Ok(Command::String(Box::new(String::Manipulation(
483 StringManipulation::Prepend(StringPrepend {
484 string_variable: token(b"str_var1"),
485 input: tokens_vec([b"input1", b"input2"]),
486 })
487 )))),
488 Ok(Command::String(Box::new(String::Manipulation(
489 StringManipulation::Concat(StringConcat {
490 output_variable: token(b"out_var1"),
491 input: tokens_vec([b"input1", b"input2"]),
492 })
493 )))),
494 Ok(Command::String(Box::new(String::Manipulation(
495 StringManipulation::Join(StringJoin {
496 glue: token(b","),
497 output_variable: token(b"out_var1"),
498 input: tokens_vec([b"input1", b"input2"]),
499 })
500 )))),
501 Ok(Command::String(Box::new(String::Manipulation(
502 StringManipulation::ToLower(StringToLower {
503 string: token(b"str1"),
504 output_variable: token(b"out_var1"),
505 })
506 )))),
507 Ok(Command::String(Box::new(String::Manipulation(
508 StringManipulation::ToUpper(StringToUpper {
509 string: token(b"str1"),
510 output_variable: token(b"out_var1"),
511 })
512 )))),
513 Ok(Command::String(Box::new(String::Manipulation(
514 StringManipulation::Length(StringLength {
515 string: token(b"str1"),
516 output_variable: token(b"out_var1"),
517 })
518 )))),
519 Ok(Command::String(Box::new(String::Manipulation(
520 StringManipulation::Substring(StringSubstring {
521 string: token(b"str1"),
522 begin: token(b"begin1"),
523 length: token(b"length1"),
524 output_variable: token(b"out_var1"),
525 })
526 )))),
527 Ok(Command::String(Box::new(String::Manipulation(
528 StringManipulation::Strip(StringStrip {
529 string: token(b"str1"),
530 output_variable: token(b"out_var1"),
531 })
532 )))),
533 Ok(Command::String(Box::new(String::Manipulation(
534 StringManipulation::GenexStrip(StringGenexStrip {
535 string: token(b"str1"),
536 output_variable: token(b"out_var1"),
537 })
538 )))),
539 Ok(Command::String(Box::new(String::Manipulation(
540 StringManipulation::Repeat(StringRepeat {
541 string: token(b"str1"),
542 count: token(b"count1"),
543 output_variable: token(b"out_var1"),
544 })
545 )))),
546 Ok(Command::String(Box::new(String::Comparison(
547 StringComparison::Less(StringLess {
548 string1: token(b"str1"),
549 string2: token(b"str2"),
550 output_variable: token(b"out_var1"),
551 })
552 )))),
553 Ok(Command::String(Box::new(String::Comparison(
554 StringComparison::Greater(StringGreater {
555 string1: token(b"str1"),
556 string2: token(b"str2"),
557 output_variable: token(b"out_var1"),
558 })
559 )))),
560 Ok(Command::String(Box::new(String::Comparison(
561 StringComparison::Equal(StringEqual {
562 string1: token(b"str1"),
563 string2: token(b"str2"),
564 output_variable: token(b"out_var1"),
565 })
566 )))),
567 Ok(Command::String(Box::new(String::Comparison(
568 StringComparison::NotEqual(StringNotEqual {
569 string1: token(b"str1"),
570 string2: token(b"str2"),
571 output_variable: token(b"out_var1"),
572 })
573 )))),
574 Ok(Command::String(Box::new(String::Comparison(
575 StringComparison::LessEqual(StringLessEqual {
576 string1: token(b"str1"),
577 string2: token(b"str2"),
578 output_variable: token(b"out_var1"),
579 })
580 )))),
581 Ok(Command::String(Box::new(String::Comparison(
582 StringComparison::GreaterEqual(StringGreaterEqual {
583 string1: token(b"str1"),
584 string2: token(b"str2"),
585 output_variable: token(b"out_var1"),
586 })
587 )))),
588 Ok(Command::String(Box::new(String::Hash(StringHash {
589 hash_algorithm: HashAlgorithm::MD5,
590 output_variable: token(b"out_var1"),
591 input: token(b"input1"),
592 })))),
593 Ok(Command::String(Box::new(String::Generation(
594 StringGeneration::Ascii(StringAscii {
595 number: tokens_vec([b"number1", b"number2"]),
596 output_variable: token(b"out_var1"),
597 })
598 )))),
599 Ok(Command::String(Box::new(String::Generation(
600 StringGeneration::Hex(StringHex {
601 string: token(b"str1"),
602 output_variable: token(b"out_var1"),
603 })
604 )))),
605 Ok(Command::String(Box::new(String::Generation(
606 StringGeneration::Configure(StringConfigure {
607 string: token(b"str1"),
608 output_variable: token(b"out_var1"),
609 only: false,
610 escape_quotes: false,
611 })
612 )))),
613 Ok(Command::String(Box::new(String::Generation(
614 StringGeneration::Configure(StringConfigure {
615 string: token(b"str1"),
616 output_variable: token(b"out_var1"),
617 only: true,
618 escape_quotes: false,
619 })
620 )))),
621 Ok(Command::String(Box::new(String::Generation(
622 StringGeneration::Configure(StringConfigure {
623 string: token(b"str1"),
624 output_variable: token(b"out_var1"),
625 only: false,
626 escape_quotes: true,
627 })
628 )))),
629 Ok(Command::String(Box::new(String::Generation(
630 StringGeneration::Configure(StringConfigure {
631 string: token(b"str1"),
632 output_variable: token(b"out_var1"),
633 only: true,
634 escape_quotes: true,
635 })
636 )))),
637 Ok(Command::String(Box::new(String::Generation(
638 StringGeneration::MakeCIdentifier(StringMakeCIdentifier {
639 string: token(b"str1"),
640 output_variable: token(b"out_var1"),
641 })
642 )))),
643 Ok(Command::String(Box::new(String::Generation(
644 StringGeneration::Random(StringRandom {
645 length: Some(token(b"len1")),
646 alphabet: Some(token(b"abc1")),
647 random_seed: Some(token(b"seed1")),
648 output_variable: token(b"out_var1"),
649 })
650 )))),
651 Ok(Command::String(Box::new(String::Generation(
652 StringGeneration::Random(StringRandom {
653 length: None,
654 alphabet: None,
655 random_seed: None,
656 output_variable: token(b"out_var1"),
657 })
658 )))),
659 Ok(Command::String(Box::new(String::Generation(
660 StringGeneration::Timestamp(StringTimestamp {
661 output_variable: token(b"out_var1"),
662 format_string: None,
663 utc: false,
664 })
665 )))),
666 Ok(Command::String(Box::new(String::Generation(
667 StringGeneration::Timestamp(StringTimestamp {
668 output_variable: token(b"out_var1"),
669 format_string: Some(token(b"format1")),
670 utc: false,
671 })
672 )))),
673 Ok(Command::String(Box::new(String::Generation(
674 StringGeneration::Timestamp(StringTimestamp {
675 output_variable: token(b"out_var1"),
676 format_string: Some(token(b"format1")),
677 utc: true,
678 })
679 )))),
680 Ok(Command::String(Box::new(String::Generation(
681 StringGeneration::Timestamp(StringTimestamp {
682 output_variable: token(b"out_var1"),
683 format_string: None,
684 utc: true,
685 })
686 )))),
687 Ok(Command::String(Box::new(String::Generation(
688 StringGeneration::Uuid(StringUuid {
689 output_variable: token(b"out_var1"),
690 namespace: token(b"namespace1"),
691 name: token(b"name1"),
692 hash_algorithm: UuidHashAlgorithm::MD5,
693 upper: true,
694 })
695 )))),
696 Ok(Command::String(Box::new(String::Generation(
697 StringGeneration::Uuid(StringUuid {
698 output_variable: token(b"out_var1"),
699 namespace: token(b"namespace1"),
700 name: token(b"name1"),
701 hash_algorithm: UuidHashAlgorithm::SHA1,
702 upper: false,
703 })
704 )))),
705 Ok(Command::String(Box::new(String::Json(StringJson {
706 output_variable: token(b"out_var1"),
707 error_variable: None,
708 command: JsonCommand::Get(StringJsonGet {
709 json_string: token(b"json_str1"),
710 member_index: tokens_vec([b"member1", b"member2"]),
711 }),
712 })))),
713 Ok(Command::String(Box::new(String::Json(StringJson {
714 output_variable: token(b"out_var1"),
715 error_variable: Some(token(b"err_var1")),
716 command: JsonCommand::Get(StringJsonGet {
717 json_string: token(b"json_str1"),
718 member_index: tokens_vec([b"member1", b"member2"]),
719 }),
720 })))),
721 Ok(Command::String(Box::new(String::Json(StringJson {
722 output_variable: token(b"out_var1"),
723 error_variable: None,
724 command: JsonCommand::Type(StringJsonType {
725 json_string: token(b"json_str1"),
726 member_index: tokens_vec([b"member1", b"member2"]),
727 }),
728 })))),
729 Ok(Command::String(Box::new(String::Json(StringJson {
730 output_variable: token(b"out_var1"),
731 error_variable: Some(token(b"err_var1")),
732 command: JsonCommand::Type(StringJsonType {
733 json_string: token(b"json_str1"),
734 member_index: tokens_vec([b"member1", b"member2"]),
735 }),
736 })))),
737 Ok(Command::String(Box::new(String::Json(StringJson {
738 output_variable: token(b"out_var1"),
739 error_variable: None,
740 command: JsonCommand::Member(StringJsonMember {
741 json_string: token(b"json_str1"),
742 member_index: Some(tokens_vec([b"member1", b"member2"])),
743 index: token(b"idx1"),
744 }),
745 })))),
746 Ok(Command::String(Box::new(String::Json(StringJson {
747 output_variable: token(b"out_var1"),
748 error_variable: Some(token(b"err_var1")),
749 command: JsonCommand::Member(StringJsonMember {
750 json_string: token(b"json_str1"),
751 member_index: None,
752 index: token(b"idx1"),
753 }),
754 })))),
755 Ok(Command::String(Box::new(String::Json(StringJson {
756 output_variable: token(b"out_var1"),
757 error_variable: None,
758 command: JsonCommand::Length(StringJsonLength {
759 json_string: token(b"json_str1"),
760 member_index: Some(tokens_vec([b"member1", b"member2"])),
761 }),
762 })))),
763 Ok(Command::String(Box::new(String::Json(StringJson {
764 output_variable: token(b"out_var1"),
765 error_variable: Some(token(b"err_var1")),
766 command: JsonCommand::Length(StringJsonLength {
767 json_string: token(b"json_str1"),
768 member_index: None,
769 }),
770 })))),
771 Ok(Command::String(Box::new(String::Json(StringJson {
772 output_variable: token(b"out_var1"),
773 error_variable: None,
774 command: JsonCommand::Remove(StringJsonRemove {
775 json_string: token(b"json_str1"),
776 member_index: tokens_vec([b"member1", b"member2"]),
777 }),
778 })))),
779 Ok(Command::String(Box::new(String::Json(StringJson {
780 output_variable: token(b"out_var1"),
781 error_variable: Some(token(b"err_var1")),
782 command: JsonCommand::Remove(StringJsonRemove {
783 json_string: token(b"json_str1"),
784 member_index: tokens_vec([b"member1", b"member2"]),
785 }),
786 })))),
787 Ok(Command::String(Box::new(String::Json(StringJson {
788 output_variable: token(b"out_var1"),
789 error_variable: None,
790 command: JsonCommand::Set(StringJsonSet {
791 json_string: token(b"json_str1"),
792 member_index: tokens_vec([b"member1", b"member2"]),
793 value: token(b"value1"),
794 }),
795 })))),
796 Ok(Command::String(Box::new(String::Json(StringJson {
797 output_variable: token(b"out_var1"),
798 error_variable: Some(token(b"err_var1")),
799 command: JsonCommand::Set(StringJsonSet {
800 json_string: token(b"json_str1"),
801 member_index: tokens_vec([b"member1"]),
802 value: token(b"value1"),
803 }),
804 })))),
805 Ok(Command::String(Box::new(String::Json(StringJson {
806 output_variable: token(b"out_var1"),
807 error_variable: None,
808 command: JsonCommand::Equal(StringJsonEqual {
809 json_string1: token(b"json_str1"),
810 json_string2: token(b"json_str2"),
811 }),
812 })))),
813 Ok(Command::String(Box::new(String::Json(StringJson {
814 output_variable: token(b"out_var1"),
815 error_variable: Some(token(b"err_var1")),
816 command: JsonCommand::Equal(StringJsonEqual {
817 json_string1: token(b"json_str1"),
818 json_string2: token(b"json_str2"),
819 }),
820 })))),
821 ]
822 )
823 }
824}