1//! Parsing of [Rust `fmt` syntax][0].
2//!
3//! [0]: std::fmt#syntax
4
5use std::iter;
6
7use unicode_xid::UnicodeXID as XID;
8
9/// Output of the [`format_string`] parser.
10#[derive(Clone, Debug, Eq, PartialEq)]
11pub(crate) struct FormatString<'a> {
12 pub(crate) formats: Vec<Format<'a>>,
13}
14
15/// Output of the [`format`] parser.
16///
17/// [`format`]: fn@format
18#[derive(Debug, Clone, Copy, Eq, PartialEq)]
19pub(crate) struct Format<'a> {
20 pub(crate) arg: Option<Argument<'a>>,
21 pub(crate) spec: Option<FormatSpec<'a>>,
22}
23
24/// Output of the [`format_spec`] parser.
25#[derive(Clone, Copy, Debug, Eq, PartialEq)]
26pub(crate) struct FormatSpec<'a> {
27 /// Parsed `[[fill]`[`align`]`]`.
28 pub(crate) align: Option<(Option<Fill>, Align)>,
29
30 /// Parsed `[`[`sign`]`]`.
31 pub(crate) sign: Option<Sign>,
32
33 /// Parsed `['#']` (alternation).
34 pub(crate) alternate: Option<Alternate>,
35
36 /// Parsed `['0']` (padding with zeros).
37 pub(crate) zero_padding: Option<ZeroPadding>,
38
39 /// Parsed `[width]`.
40 pub(crate) width: Option<Width<'a>>,
41
42 /// Parsed `['.' `[`precision`]`]`.
43 pub(crate) precision: Option<Precision<'a>>,
44
45 /// Parsed [`type`].
46 ///
47 /// [`type`]: type_
48 pub(crate) ty: Type,
49}
50
51/// Output of the [`argument`] parser.
52#[derive(Clone, Copy, Debug, Eq, PartialEq)]
53pub(crate) enum Argument<'a> {
54 Integer(usize),
55 Identifier(&'a str),
56}
57
58/// Output of the [`align`] parser.
59#[derive(Clone, Copy, Debug, Eq, PartialEq)]
60pub(crate) enum Align {
61 Left,
62 Center,
63 Right,
64}
65
66/// Output of the [`sign`] parser.
67#[derive(Clone, Copy, Debug, Eq, PartialEq)]
68pub(crate) enum Sign {
69 Plus,
70 Minus,
71}
72
73/// Type for the [`FormatSpec::alternate`].
74#[derive(Clone, Copy, Debug, Eq, PartialEq)]
75pub(crate) struct Alternate;
76
77/// Type for the [`FormatSpec::zero_padding`].
78#[derive(Clone, Copy, Debug, Eq, PartialEq)]
79pub(crate) struct ZeroPadding;
80
81/// Output of the [`precision`] parser.
82#[derive(Clone, Copy, Debug, Eq, PartialEq)]
83pub(crate) enum Precision<'a> {
84 Count(Count<'a>),
85 Star,
86}
87
88/// Output of the [`count`] parser.
89#[derive(Clone, Copy, Debug, Eq, PartialEq)]
90pub(crate) enum Count<'a> {
91 Integer(usize),
92 Parameter(Parameter<'a>),
93}
94
95/// Output of the [`type_`] parser. See [formatting traits][0] for more info.
96///
97/// [0]: std::fmt#formatting-traits
98#[derive(Clone, Copy, Debug, Eq, PartialEq)]
99pub(crate) enum Type {
100 Display,
101 Debug,
102 LowerDebug,
103 UpperDebug,
104 Octal,
105 LowerHex,
106 UpperHex,
107 Pointer,
108 Binary,
109 LowerExp,
110 UpperExp,
111}
112
113impl Type {
114 /// Returns trait name of this [`Type`].
115 pub(crate) fn trait_name(&self) -> &'static str {
116 match self {
117 Self::Display => "Display",
118 Self::Debug | Self::LowerDebug | Self::UpperDebug => "Debug",
119 Self::Octal => "Octal",
120 Self::LowerHex => "LowerHex",
121 Self::UpperHex => "UpperHex",
122 Self::Pointer => "Pointer",
123 Self::Binary => "Binary",
124 Self::LowerExp => "LowerExp",
125 Self::UpperExp => "UpperExp",
126 }
127 }
128
129 /// Indicates whether this [`Type`] represents a trivial trait call without any modifications.
130 pub(crate) fn is_trivial(&self) -> bool {
131 match self {
132 Self::Display
133 | Self::Debug
134 | Self::Octal
135 | Self::LowerHex
136 | Self::UpperHex
137 | Self::Pointer
138 | Self::Binary
139 | Self::LowerExp
140 | Self::UpperExp => true,
141 Self::LowerDebug | Self::UpperDebug => false,
142 }
143 }
144}
145
146/// Type alias for the `fill` in the [`FormatSpec::align`].
147type Fill = char;
148
149/// Type alias for the [`FormatSpec::width`].
150type Width<'a> = Count<'a>;
151
152/// Output of the [`maybe_format`] parser.
153type MaybeFormat<'a> = Option<Format<'a>>;
154
155/// Output of the [`identifier`] parser.
156type Identifier<'a> = &'a str;
157
158/// Output of the [`parameter`] parser.
159type Parameter<'a> = Argument<'a>;
160
161/// [`str`] left to parse.
162///
163/// [`str`]: prim@str
164type LeftToParse<'a> = &'a str;
165
166/// Parses a `format_string` as defined in the [grammar spec][0].
167///
168/// # Grammar
169///
170/// [`format_string`]` := `[`text`]` [`[`maybe_format text`]`] *`
171///
172/// # Example
173///
174/// ```text
175/// Hello
176/// Hello, {}!
177/// {:?}
178/// Hello {people}!
179/// {} {}
180/// {:04}
181/// {par:-^#.0$?}
182/// ```
183///
184/// # Return value
185///
186/// - [`Some`] in case of successful parse.
187/// - [`None`] otherwise (not all characters are consumed by underlying
188/// parsers).
189///
190/// [0]: std::fmt#syntax
191pub(crate) fn format_string(input: &str) -> Option<FormatString<'_>> {
192 let (mut input: &str, _) = optional_result(parser:text)(input);
193
194 let formats: Vec> = iterimpl Iterator>::repeat(())
195 .scan(&mut input, |input: &mut &mut &str, _| {
196 let (curr: &str, format: Option>) =
197 alt(&mut [&mut maybe_format, &mut map(parser:text, |(i: &str, _)| (i, None))])(
198 input,
199 )?;
200 **input = curr;
201 Some(format)
202 })
203 .flatten()
204 .collect();
205
206 // Should consume all tokens for a successful parse.
207 input.is_empty().then_some(FormatString { formats })
208}
209
210/// Parses a `maybe_format` as defined in the [grammar spec][0].
211///
212/// # Grammar
213///
214/// [`maybe_format`]` := '{' '{' | '}' '}' | `[`format`]
215///
216/// # Example
217///
218/// ```text
219/// {{
220/// }}
221/// {:04}
222/// {:#?}
223/// {par:-^#.0$?}
224/// ```
225///
226/// [`format`]: fn@format
227/// [0]: std::fmt#syntax
228fn maybe_format(input: &str) -> Option<(LeftToParse<'_>, MaybeFormat<'_>)> {
229 alt(&mut [
230 &mut map(parser:str("{{"), |i: &str| (i, None)),
231 &mut map(parser:str("}}"), |i: &str| (i, None)),
232 &mut map(parser:format, |(i: &str, format: Format<'_>)| (i, Some(format))),
233 ])(input)
234}
235
236/// Parses a `format` as defined in the [grammar spec][0].
237///
238/// # Grammar
239///
240/// [`format`]` := '{' [`[`argument`]`] [':' `[`format_spec`]`] '}'`
241///
242/// # Example
243///
244/// ```text
245/// {par}
246/// {:#?}
247/// {par:-^#.0$?}
248/// ```
249///
250/// [`format`]: fn@format
251/// [0]: std::fmt#syntax
252pub(crate) fn format(input: &str) -> Option<(LeftToParse<'_>, Format<'_>)> {
253 let input: &str = char('{')(input)?;
254
255 let (input: &str, arg: Option>) = optional_result(parser:argument)(input);
256
257 let (input: &str, spec: Option>) = map_or_else(
258 parser:char(':'),
259 |i| Some((i, None)),
260 f:map(parser:format_spec, |(i: &str, s: FormatSpec<'_>)| (i, Some(s))),
261 )(input)?;
262
263 let input: &str = char('}')(input)?;
264
265 Some((input, Format { arg, spec }))
266}
267
268/// Parses an `argument` as defined in the [grammar spec][0].
269///
270/// # Grammar
271///
272/// [`argument`]` := `[`integer`]` | `[`identifier`]
273///
274/// # Example
275///
276/// ```text
277/// 0
278/// ident
279/// Минск
280/// ```
281///
282/// [0]: std::fmt#syntax
283fn argument(input: &str) -> Option<(LeftToParse<'_>, Argument)> {
284 alt(&mut [
285 &mut map(parser:identifier, |(i: &str, ident: &str)| (i, Argument::Identifier(ident))),
286 &mut map(parser:integer, |(i: &str, int: usize)| (i, Argument::Integer(int))),
287 ])(input)
288}
289
290/// Parses a `format_spec` as defined in the [grammar spec][0].
291///
292/// # Grammar
293///
294/// [`format_spec`]` := [[fill]`[`align`]`][`[`sign`]`]['#']['0'][width]`
295/// `['.' `[`precision`]`]`[`type`]
296///
297/// # Example
298///
299/// ```text
300/// ^
301/// <^
302/// ->+#0width$.precision$x?
303/// ```
304///
305/// [`type`]: type_
306/// [0]: std::fmt#syntax
307fn format_spec(input: &str) -> Option<(LeftToParse<'_>, FormatSpec<'_>)> {
308 let (input, align) = optional_result(alt(&mut [
309 &mut and_then(take_any_char, |(i, fill)| {
310 map(align, |(i, align)| (i, (Some(fill), align)))(i)
311 }),
312 &mut map(align, |(i, align)| (i, (None, align))),
313 ]))(input);
314
315 let (input, sign) = optional_result(sign)(input);
316
317 let (input, alternate) = optional_result(map(char('#'), |i| (i, Alternate)))(input);
318
319 let (input, zero_padding) = optional_result(map(
320 try_seq(&mut [
321 &mut char('0'),
322 &mut lookahead(check_char(|c| !matches!(c, '$'))),
323 ]),
324 |i| (i, ZeroPadding),
325 ))(input);
326
327 let (input, width) = optional_result(count)(input);
328
329 let (input, precision) = map_or_else(
330 char('.'),
331 |i| Some((i, None)),
332 map(precision, |(i, p)| (i, Some(p))),
333 )(input)?;
334
335 let (input, ty) = type_(input)?;
336
337 Some((
338 input,
339 FormatSpec {
340 align,
341 sign,
342 alternate,
343 zero_padding,
344 width,
345 precision,
346 ty,
347 },
348 ))
349}
350
351/// Parses an `align` as defined in the [grammar spec][0].
352///
353/// # Grammar
354///
355/// [`align`]` := '<' | '^' | '>'`
356///
357/// # Example
358///
359/// ```text
360/// <
361/// ^
362/// >
363/// ```
364///
365/// [0]: std::fmt#syntax
366fn align(input: &str) -> Option<(LeftToParse<'_>, Align)> {
367 alt(&mut [
368 &mut map(parser:char('<'), |i: &str| (i, Align::Left)),
369 &mut map(parser:char('^'), |i: &str| (i, Align::Center)),
370 &mut map(parser:char('>'), |i: &str| (i, Align::Right)),
371 ])(input)
372}
373
374/// Parses a `sign` as defined in the [grammar spec][0].
375///
376/// # Grammar
377///
378/// [`sign`]` := '+' | '-'`
379///
380/// # Example
381///
382/// ```text
383/// +
384/// -
385/// ```
386///
387/// [0]: std::fmt#syntax
388fn sign(input: &str) -> Option<(LeftToParse<'_>, Sign)> {
389 alt(&mut [
390 &mut map(parser:char('+'), |i: &str| (i, Sign::Plus)),
391 &mut map(parser:char('-'), |i: &str| (i, Sign::Minus)),
392 ])(input)
393}
394
395/// Parses a `precision` as defined in the [grammar spec][0].
396///
397/// # Grammar
398///
399/// [`precision`]` := `[`count`]` | '*'`
400///
401/// # Example
402///
403/// ```text
404/// 0
405/// 42$
406/// par$
407/// *
408/// ```
409///
410/// [0]: std::fmt#syntax
411fn precision(input: &str) -> Option<(LeftToParse<'_>, Precision<'_>)> {
412 alt(&mut [
413 &mut map(parser:count, |(i: &str, c: Count<'_>)| (i, Precision::Count(c))),
414 &mut map(parser:char('*'), |i: &str| (i, Precision::Star)),
415 ])(input)
416}
417
418/// Parses a `type` as defined in the [grammar spec][0].
419///
420/// # Grammar
421///
422/// [`type`]` := '' | '?' | 'x?' | 'X?' | identifier`
423///
424/// # Example
425///
426/// All possible [`Type`]s.
427///
428/// ```text
429/// ?
430/// x?
431/// X?
432/// o
433/// x
434/// X
435/// p
436/// b
437/// e
438/// E
439/// ```
440///
441/// [`type`]: type_
442/// [0]: std::fmt#syntax
443fn type_(input: &str) -> Option<(&str, Type)> {
444 alt(&mut [
445 &mut map(parser:str("x?"), |i: &str| (i, Type::LowerDebug)),
446 &mut map(parser:str("X?"), |i: &str| (i, Type::UpperDebug)),
447 &mut map(parser:char('?'), |i: &str| (i, Type::Debug)),
448 &mut map(parser:char('o'), |i: &str| (i, Type::Octal)),
449 &mut map(parser:char('x'), |i: &str| (i, Type::LowerHex)),
450 &mut map(parser:char('X'), |i: &str| (i, Type::UpperHex)),
451 &mut map(parser:char('p'), |i: &str| (i, Type::Pointer)),
452 &mut map(parser:char('b'), |i: &str| (i, Type::Binary)),
453 &mut map(parser:char('e'), |i: &str| (i, Type::LowerExp)),
454 &mut map(parser:char('E'), |i: &str| (i, Type::UpperExp)),
455 &mut map(parser:lookahead(char('}')), |i: &str| (i, Type::Display)),
456 ])(input)
457}
458
459/// Parses a `count` as defined in the [grammar spec][0].
460///
461/// # Grammar
462///
463/// [`count`]` := `[`parameter`]` | `[`integer`]
464///
465/// # Example
466///
467/// ```text
468/// 0
469/// 42$
470/// par$
471/// ```
472///
473/// [0]: std::fmt#syntax
474fn count(input: &str) -> Option<(LeftToParse<'_>, Count<'_>)> {
475 alt(&mut [
476 &mut map(parser:parameter, |(i: &str, p: Argument<'_>)| (i, Count::Parameter(p))),
477 &mut map(parser:integer, |(i: &str, int: usize)| (i, Count::Integer(int))),
478 ])(input)
479}
480
481/// Parses a `parameter` as defined in the [grammar spec][0].
482///
483/// # Grammar
484///
485/// [`parameter`]` := `[`argument`]` '$'`
486///
487/// # Example
488///
489/// ```text
490/// 42$
491/// par$
492/// ```
493///
494/// [0]: std::fmt#syntax
495fn parameter(input: &str) -> Option<(LeftToParse<'_>, Parameter<'_>)> {
496 and_then(parser:argument, |(i: &str, arg: Argument<'_>)| map(parser:char('$'), |i: &str| (i, arg))(i))(input)
497}
498
499/// Parses an `identifier` as defined in the [grammar spec][0].
500///
501/// # Grammar
502///
503/// `IDENTIFIER_OR_KEYWORD : XID_Start XID_Continue* | _ XID_Continue+`
504///
505/// See [rust reference][2] for more info.
506///
507/// # Example
508///
509/// ```text
510/// identifier
511/// Минск
512/// ```
513///
514/// [0]: std::fmt#syntax
515/// [2]: https://doc.rust-lang.org/reference/identifiers.html
516fn identifier(input: &str) -> Option<(LeftToParse<'_>, Identifier<'_>)> {
517 map(
518 parser:alt(&mut [
519 &mut map(
520 check_char(XID::is_xid_start),
521 take_while0(check_char(XID::is_xid_continue)),
522 ),
523 &mut and_then(char('_'), take_while1(check_char(XID::is_xid_continue))),
524 ]),
525 |(i: &str, _)| (i, &input[..(input.len() - i.len())]),
526 )(input)
527}
528
529/// Parses an `integer` as defined in the [grammar spec][0].
530///
531/// [0]: std::fmt#syntax
532fn integer(input: &str) -> Option<(LeftToParse<'_>, usize)> {
533 and_then(
534 parser:take_while1(check_char(|c| c.is_ascii_digit())),
535 |(i: &str, int: &str)| int.parse().ok().map(|int: usize| (i, int)),
536 )(input)
537}
538
539/// Parses a `text` as defined in the [grammar spec][0].
540///
541/// [0]: std::fmt#syntax
542fn text(input: &str) -> Option<(LeftToParse<'_>, &str)> {
543 take_until1(basic:any_char, until:one_of(chars:"{}"))(input)
544}
545
546type FallibleParser<'p> = &'p mut dyn FnMut(&str) -> Option<&str>;
547
548/// Tries to apply parsers in sequence. Returns [`None`] in case one of them
549/// returned [`None`].
550fn try_seq<'p>(
551 parsers: &'p mut [FallibleParser<'p>],
552) -> impl FnMut(&str) -> Option<LeftToParse<'_>> + 'p {
553 move |input: &str| parsers.iter_mut().try_fold(init:input, |i: &str, p: &mut &'p mut (dyn FnMut(&str) -> Option<…> + 'static)| (**p)(i))
554}
555
556/// Returns first successful parser or [`None`] in case all of them returned
557/// [`None`].
558fn alt<'p, 'i, T: 'i>(
559 parsers: &'p mut [&'p mut dyn FnMut(&'i str) -> Option<T>],
560) -> impl FnMut(&'i str) -> Option<T> + 'p {
561 move |input: &'i str| parsers.iter_mut().find_map(|p: &mut &'p mut (dyn FnMut(&'i str) -> Option<…> + 'static)| (**p)(input))
562}
563
564/// Maps output of the parser in case it returned [`Some`].
565fn map<'i, I: 'i, O: 'i>(
566 mut parser: impl FnMut(&'i str) -> Option<I>,
567 mut f: impl FnMut(I) -> O,
568) -> impl FnMut(&'i str) -> Option<O> {
569 move |input: &'i str| parser(input).map(&mut f)
570}
571
572/// Maps output of the parser in case it returned [`Some`] or uses `default`.
573fn map_or_else<'i, I: 'i, O: 'i>(
574 mut parser: impl FnMut(&'i str) -> Option<I>,
575 mut default: impl FnMut(&'i str) -> O,
576 mut f: impl FnMut(I) -> O,
577) -> impl FnMut(&'i str) -> O {
578 move |input: &'i str| parser(input).map_or_else(|| default(input), &mut f)
579}
580
581/// Returns [`None`] if the parser returned is [`None`], otherwise calls `f`
582/// with the wrapped value and returns the result.
583fn and_then<'i, I: 'i, O: 'i>(
584 mut parser: impl FnMut(&'i str) -> Option<I>,
585 mut f: impl FnMut(I) -> Option<O>,
586) -> impl FnMut(&'i str) -> Option<O> {
587 move |input: &'i str| parser(input).and_then(&mut f)
588}
589
590/// Checks whether `parser` is successful while not advancing the original
591/// `input`.
592fn lookahead(
593 mut parser: impl FnMut(&str) -> Option<&str>,
594) -> impl FnMut(&str) -> Option<LeftToParse<'_>> {
595 move |input: &str| map(&mut parser, |_| input)(input)
596}
597
598/// Makes underlying `parser` optional by returning the original `input` and
599/// [`None`] in case it returned [`None`].
600fn optional_result<'i, T: 'i>(
601 mut parser: impl FnMut(&'i str) -> Option<(&'i str, T)>,
602) -> impl FnMut(&'i str) -> (LeftToParse<'i>, Option<T>) {
603 move |input: &str| {
604 map_or_else(&mut parser, |i| (i, None), |(i: &'i str, c: T)| (i, Some(c)))(input)
605 }
606}
607
608/// Parses while `parser` is successful. Never fails.
609fn take_while0(
610 mut parser: impl FnMut(&str) -> Option<&str>,
611) -> impl FnMut(&str) -> (LeftToParse<'_>, &str) {
612 move |input: &str| {
613 let mut cur: &str = input;
614 while let Some(step: &str) = parser(cur) {
615 cur = step;
616 }
617 (cur, &input[..(input.len() - cur.len())])
618 }
619}
620
621/// Parses while `parser` is successful. Returns [`None`] in case `parser` never
622/// succeeded.
623fn take_while1(
624 mut parser: impl FnMut(&str) -> Option<&str>,
625) -> impl FnMut(&str) -> Option<(LeftToParse<'_>, &str)> {
626 move |input: &str| {
627 let mut cur: &str = parser(input)?;
628 while let Some(step: &str) = parser(cur) {
629 cur = step;
630 }
631 Some((cur, &input[..(input.len() - cur.len())]))
632 }
633}
634
635/// Parses with `basic` while `until` returns [`None`]. Returns [`None`] in case
636/// `until` succeeded initially or `basic` never succeeded. Doesn't consume
637/// [`char`]s parsed by `until`.
638///
639/// [`char`]: fn@char
640fn take_until1(
641 mut basic: impl FnMut(&str) -> Option<&str>,
642 mut until: impl FnMut(&str) -> Option<&str>,
643) -> impl FnMut(&str) -> Option<(LeftToParse<'_>, &str)> {
644 move |input: &str| {
645 if until(input).is_some() {
646 return None;
647 }
648 let mut cur: &str = basic(input)?;
649 loop {
650 if until(cur).is_some() {
651 break;
652 }
653 let Some(b: &str) = basic(cur) else {
654 break;
655 };
656 cur = b;
657 }
658
659 Some((cur, &input[..(input.len() - cur.len())]))
660 }
661}
662
663/// Checks whether `input` starts with `s`.
664fn str(s: &str) -> impl FnMut(&str) -> Option<LeftToParse<'_>> + '_ {
665 move |input: &str| input.starts_with(s).then(|| &input[s.len()..])
666}
667
668/// Checks whether `input` starts with `c`.
669fn char(c: char) -> impl FnMut(&str) -> Option<LeftToParse<'_>> {
670 move |input: &str| input.starts_with(c).then(|| &input[c.len_utf8()..])
671}
672
673/// Checks whether first [`char`] suits `check`.
674///
675/// [`char`]: fn@char
676fn check_char(
677 mut check: impl FnMut(char) -> bool,
678) -> impl FnMut(&str) -> Option<LeftToParse<'_>> {
679 move |input: &str| {
680 inputOption
681 .chars()
682 .next()
683 .and_then(|c: char| check(c).then(|| &input[c.len_utf8()..]))
684 }
685}
686
687/// Checks whether first [`char`] of input is present in `chars`.
688///
689/// [`char`]: fn@char
690fn one_of(chars: &str) -> impl FnMut(&str) -> Option<LeftToParse<'_>> + '_ {
691 move |input: &str| chars.chars().find_map(|c: char| char(c)(input))
692}
693
694/// Parses any [`char`].
695///
696/// [`char`]: fn@char
697fn any_char(input: &str) -> Option<LeftToParse<'_>> {
698 input.chars().next().map(|c: char| &input[c.len_utf8()..])
699}
700
701/// Parses any [`char`] and returns it.
702///
703/// [`char`]: fn@char
704fn take_any_char(input: &str) -> Option<(LeftToParse<'_>, char)> {
705 input.chars().next().map(|c: char| (&input[c.len_utf8()..], c))
706}
707
708#[cfg(test)]
709mod tests {
710 use super::*;
711
712 #[test]
713 fn text() {
714 assert_eq!(format_string(""), Some(FormatString { formats: vec![] }));
715 assert_eq!(
716 format_string("test"),
717 Some(FormatString { formats: vec![] }),
718 );
719 assert_eq!(
720 format_string("Минск"),
721 Some(FormatString { formats: vec![] }),
722 );
723 assert_eq!(format_string("🦀"), Some(FormatString { formats: vec![] }));
724 }
725
726 #[test]
727 fn argument() {
728 assert_eq!(
729 format_string("{}"),
730 Some(FormatString {
731 formats: vec![Format {
732 arg: None,
733 spec: None,
734 }],
735 }),
736 );
737 assert_eq!(
738 format_string("{0}"),
739 Some(FormatString {
740 formats: vec![Format {
741 arg: Some(Argument::Integer(0)),
742 spec: None,
743 }],
744 }),
745 );
746 assert_eq!(
747 format_string("{par}"),
748 Some(FormatString {
749 formats: vec![Format {
750 arg: Some(Argument::Identifier("par")),
751 spec: None,
752 }],
753 }),
754 );
755 assert_eq!(
756 format_string("{Минск}"),
757 Some(FormatString {
758 formats: vec![Format {
759 arg: Some(Argument::Identifier("Минск")),
760 spec: None,
761 }],
762 }),
763 );
764 }
765
766 #[test]
767 fn spec() {
768 assert_eq!(
769 format_string("{:}"),
770 Some(FormatString {
771 formats: vec![Format {
772 arg: None,
773 spec: Some(FormatSpec {
774 align: None,
775 sign: None,
776 alternate: None,
777 zero_padding: None,
778 width: None,
779 precision: None,
780 ty: Type::Display,
781 }),
782 }],
783 }),
784 );
785 assert_eq!(
786 format_string("{:^}"),
787 Some(FormatString {
788 formats: vec![Format {
789 arg: None,
790 spec: Some(FormatSpec {
791 align: Some((None, Align::Center)),
792 sign: None,
793 alternate: None,
794 zero_padding: None,
795 width: None,
796 precision: None,
797 ty: Type::Display,
798 }),
799 }],
800 }),
801 );
802 assert_eq!(
803 format_string("{:-<}"),
804 Some(FormatString {
805 formats: vec![Format {
806 arg: None,
807 spec: Some(FormatSpec {
808 align: Some((Some('-'), Align::Left)),
809 sign: None,
810 alternate: None,
811 zero_padding: None,
812 width: None,
813 precision: None,
814 ty: Type::Display,
815 }),
816 }],
817 }),
818 );
819 assert_eq!(
820 format_string("{: <}"),
821 Some(FormatString {
822 formats: vec![Format {
823 arg: None,
824 spec: Some(FormatSpec {
825 align: Some((Some(' '), Align::Left)),
826 sign: None,
827 alternate: None,
828 zero_padding: None,
829 width: None,
830 precision: None,
831 ty: Type::Display,
832 }),
833 }],
834 }),
835 );
836 assert_eq!(
837 format_string("{:^<}"),
838 Some(FormatString {
839 formats: vec![Format {
840 arg: None,
841 spec: Some(FormatSpec {
842 align: Some((Some('^'), Align::Left)),
843 sign: None,
844 alternate: None,
845 zero_padding: None,
846 width: None,
847 precision: None,
848 ty: Type::Display,
849 }),
850 }],
851 }),
852 );
853 assert_eq!(
854 format_string("{:+}"),
855 Some(FormatString {
856 formats: vec![Format {
857 arg: None,
858 spec: Some(FormatSpec {
859 align: None,
860 sign: Some(Sign::Plus),
861 alternate: None,
862 zero_padding: None,
863 width: None,
864 precision: None,
865 ty: Type::Display,
866 }),
867 }],
868 }),
869 );
870 assert_eq!(
871 format_string("{:^<-}"),
872 Some(FormatString {
873 formats: vec![Format {
874 arg: None,
875 spec: Some(FormatSpec {
876 align: Some((Some('^'), Align::Left)),
877 sign: Some(Sign::Minus),
878 alternate: None,
879 zero_padding: None,
880 width: None,
881 precision: None,
882 ty: Type::Display,
883 }),
884 }],
885 }),
886 );
887 assert_eq!(
888 format_string("{:#}"),
889 Some(FormatString {
890 formats: vec![Format {
891 arg: None,
892 spec: Some(FormatSpec {
893 align: None,
894 sign: None,
895 alternate: Some(Alternate),
896 zero_padding: None,
897 width: None,
898 precision: None,
899 ty: Type::Display,
900 }),
901 }],
902 }),
903 );
904 assert_eq!(
905 format_string("{:+#}"),
906 Some(FormatString {
907 formats: vec![Format {
908 arg: None,
909 spec: Some(FormatSpec {
910 align: None,
911 sign: Some(Sign::Plus),
912 alternate: Some(Alternate),
913 zero_padding: None,
914 width: None,
915 precision: None,
916 ty: Type::Display,
917 }),
918 }],
919 }),
920 );
921 assert_eq!(
922 format_string("{:-<#}"),
923 Some(FormatString {
924 formats: vec![Format {
925 arg: None,
926 spec: Some(FormatSpec {
927 align: Some((Some('-'), Align::Left)),
928 sign: None,
929 alternate: Some(Alternate),
930 zero_padding: None,
931 width: None,
932 precision: None,
933 ty: Type::Display,
934 }),
935 }],
936 }),
937 );
938 assert_eq!(
939 format_string("{:^<-#}"),
940 Some(FormatString {
941 formats: vec![Format {
942 arg: None,
943 spec: Some(FormatSpec {
944 align: Some((Some('^'), Align::Left)),
945 sign: Some(Sign::Minus),
946 alternate: Some(Alternate),
947 zero_padding: None,
948 width: None,
949 precision: None,
950 ty: Type::Display,
951 }),
952 }],
953 }),
954 );
955 assert_eq!(
956 format_string("{:0}"),
957 Some(FormatString {
958 formats: vec![Format {
959 arg: None,
960 spec: Some(FormatSpec {
961 align: None,
962 sign: None,
963 alternate: None,
964 zero_padding: Some(ZeroPadding),
965 width: None,
966 precision: None,
967 ty: Type::Display,
968 }),
969 }],
970 }),
971 );
972 assert_eq!(
973 format_string("{:#0}"),
974 Some(FormatString {
975 formats: vec![Format {
976 arg: None,
977 spec: Some(FormatSpec {
978 align: None,
979 sign: None,
980 alternate: Some(Alternate),
981 zero_padding: Some(ZeroPadding),
982 width: None,
983 precision: None,
984 ty: Type::Display,
985 }),
986 }],
987 }),
988 );
989 assert_eq!(
990 format_string("{:-0}"),
991 Some(FormatString {
992 formats: vec![Format {
993 arg: None,
994 spec: Some(FormatSpec {
995 align: None,
996 sign: Some(Sign::Minus),
997 alternate: None,
998 zero_padding: Some(ZeroPadding),
999 width: None,
1000 precision: None,
1001 ty: Type::Display,
1002 }),
1003 }],
1004 }),
1005 );
1006 assert_eq!(
1007 format_string("{:^<0}"),
1008 Some(FormatString {
1009 formats: vec![Format {
1010 arg: None,
1011 spec: Some(FormatSpec {
1012 align: Some((Some('^'), Align::Left)),
1013 sign: None,
1014 alternate: None,
1015 zero_padding: Some(ZeroPadding),
1016 width: None,
1017 precision: None,
1018 ty: Type::Display,
1019 }),
1020 }],
1021 }),
1022 );
1023 assert_eq!(
1024 format_string("{:^<+#0}"),
1025 Some(FormatString {
1026 formats: vec![Format {
1027 arg: None,
1028 spec: Some(FormatSpec {
1029 align: Some((Some('^'), Align::Left)),
1030 sign: Some(Sign::Plus),
1031 alternate: Some(Alternate),
1032 zero_padding: Some(ZeroPadding),
1033 width: None,
1034 precision: None,
1035 ty: Type::Display,
1036 }),
1037 }],
1038 }),
1039 );
1040 assert_eq!(
1041 format_string("{:1}"),
1042 Some(FormatString {
1043 formats: vec![Format {
1044 arg: None,
1045 spec: Some(FormatSpec {
1046 align: None,
1047 sign: None,
1048 alternate: None,
1049 zero_padding: None,
1050 width: Some(Count::Integer(1)),
1051 precision: None,
1052 ty: Type::Display,
1053 }),
1054 }],
1055 }),
1056 );
1057 assert_eq!(
1058 format_string("{:1$}"),
1059 Some(FormatString {
1060 formats: vec![Format {
1061 arg: None,
1062 spec: Some(FormatSpec {
1063 align: None,
1064 sign: None,
1065 alternate: None,
1066 zero_padding: None,
1067 width: Some(Count::Parameter(Argument::Integer(1))),
1068 precision: None,
1069 ty: Type::Display,
1070 }),
1071 }],
1072 }),
1073 );
1074 assert_eq!(
1075 format_string("{:par$}"),
1076 Some(FormatString {
1077 formats: vec![Format {
1078 arg: None,
1079 spec: Some(FormatSpec {
1080 align: None,
1081 sign: None,
1082 alternate: None,
1083 zero_padding: None,
1084 width: Some(Count::Parameter(Argument::Identifier("par"))),
1085 precision: None,
1086 ty: Type::Display,
1087 }),
1088 }],
1089 }),
1090 );
1091 assert_eq!(
1092 format_string("{:-^-#0Минск$}"),
1093 Some(FormatString {
1094 formats: vec![Format {
1095 arg: None,
1096 spec: Some(FormatSpec {
1097 align: Some((Some('-'), Align::Center)),
1098 sign: Some(Sign::Minus),
1099 alternate: Some(Alternate),
1100 zero_padding: Some(ZeroPadding),
1101 width: Some(Count::Parameter(Argument::Identifier("Минск"))),
1102 precision: None,
1103 ty: Type::Display,
1104 }),
1105 }],
1106 }),
1107 );
1108 assert_eq!(
1109 format_string("{:.*}"),
1110 Some(FormatString {
1111 formats: vec![Format {
1112 arg: None,
1113 spec: Some(FormatSpec {
1114 align: None,
1115 sign: None,
1116 alternate: None,
1117 zero_padding: None,
1118 width: None,
1119 precision: Some(Precision::Star),
1120 ty: Type::Display,
1121 }),
1122 }],
1123 }),
1124 );
1125 assert_eq!(
1126 format_string("{:.0}"),
1127 Some(FormatString {
1128 formats: vec![Format {
1129 arg: None,
1130 spec: Some(FormatSpec {
1131 align: None,
1132 sign: None,
1133 alternate: None,
1134 zero_padding: None,
1135 width: None,
1136 precision: Some(Precision::Count(Count::Integer(0))),
1137 ty: Type::Display,
1138 }),
1139 }],
1140 }),
1141 );
1142 assert_eq!(
1143 format_string("{:.0$}"),
1144 Some(FormatString {
1145 formats: vec![Format {
1146 arg: None,
1147 spec: Some(FormatSpec {
1148 align: None,
1149 sign: None,
1150 alternate: None,
1151 zero_padding: None,
1152 width: None,
1153 precision: Some(Precision::Count(Count::Parameter(
1154 Argument::Integer(0),
1155 ))),
1156 ty: Type::Display,
1157 }),
1158 }],
1159 }),
1160 );
1161 assert_eq!(
1162 format_string("{:.par$}"),
1163 Some(FormatString {
1164 formats: vec![Format {
1165 arg: None,
1166 spec: Some(FormatSpec {
1167 align: None,
1168 sign: None,
1169 alternate: None,
1170 zero_padding: None,
1171 width: None,
1172 precision: Some(Precision::Count(Count::Parameter(
1173 Argument::Identifier("par"),
1174 ))),
1175 ty: Type::Display,
1176 }),
1177 }],
1178 }),
1179 );
1180 assert_eq!(
1181 format_string("{: >+#2$.par$}"),
1182 Some(FormatString {
1183 formats: vec![Format {
1184 arg: None,
1185 spec: Some(FormatSpec {
1186 align: Some((Some(' '), Align::Right)),
1187 sign: Some(Sign::Plus),
1188 alternate: Some(Alternate),
1189 zero_padding: None,
1190 width: Some(Count::Parameter(Argument::Integer(2))),
1191 precision: Some(Precision::Count(Count::Parameter(
1192 Argument::Identifier("par"),
1193 ))),
1194 ty: Type::Display,
1195 }),
1196 }],
1197 }),
1198 );
1199 assert_eq!(
1200 format_string("{:x?}"),
1201 Some(FormatString {
1202 formats: vec![Format {
1203 arg: None,
1204 spec: Some(FormatSpec {
1205 align: None,
1206 sign: None,
1207 alternate: None,
1208 zero_padding: None,
1209 width: None,
1210 precision: None,
1211 ty: Type::LowerDebug,
1212 }),
1213 }],
1214 }),
1215 );
1216 assert_eq!(
1217 format_string("{:E}"),
1218 Some(FormatString {
1219 formats: vec![Format {
1220 arg: None,
1221 spec: Some(FormatSpec {
1222 align: None,
1223 sign: None,
1224 alternate: None,
1225 zero_padding: None,
1226 width: None,
1227 precision: None,
1228 ty: Type::UpperExp,
1229 }),
1230 }],
1231 }),
1232 );
1233 assert_eq!(
1234 format_string("{: >+#par$.par$X?}"),
1235 Some(FormatString {
1236 formats: vec![Format {
1237 arg: None,
1238 spec: Some(FormatSpec {
1239 align: Some((Some(' '), Align::Right)),
1240 sign: Some(Sign::Plus),
1241 alternate: Some(Alternate),
1242 zero_padding: None,
1243 width: Some(Count::Parameter(Argument::Identifier("par"))),
1244 precision: Some(Precision::Count(Count::Parameter(
1245 Argument::Identifier("par"),
1246 ))),
1247 ty: Type::UpperDebug,
1248 }),
1249 }],
1250 }),
1251 );
1252 }
1253
1254 #[test]
1255 fn full() {
1256 assert_eq!(
1257 format_string("prefix{{{0:#?}postfix{par:-^par$.a$}}}"),
1258 Some(FormatString {
1259 formats: vec![
1260 Format {
1261 arg: Some(Argument::Integer(0)),
1262 spec: Some(FormatSpec {
1263 align: None,
1264 sign: None,
1265 alternate: Some(Alternate),
1266 zero_padding: None,
1267 width: None,
1268 precision: None,
1269 ty: Type::Debug,
1270 }),
1271 },
1272 Format {
1273 arg: Some(Argument::Identifier("par")),
1274 spec: Some(FormatSpec {
1275 align: Some((Some('-'), Align::Center)),
1276 sign: None,
1277 alternate: None,
1278 zero_padding: None,
1279 width: Some(Count::Parameter(Argument::Identifier("par"))),
1280 precision: Some(Precision::Count(Count::Parameter(
1281 Argument::Identifier("a"),
1282 ))),
1283 ty: Type::Display,
1284 }),
1285 },
1286 ],
1287 }),
1288 );
1289 }
1290
1291 #[test]
1292 fn error() {
1293 assert_eq!(format_string("{"), None);
1294 assert_eq!(format_string("}"), None);
1295 assert_eq!(format_string("{{}"), None);
1296 assert_eq!(format_string("{:x?"), None);
1297 assert_eq!(format_string("{:.}"), None);
1298 assert_eq!(format_string("{:q}"), None);
1299 assert_eq!(format_string("{:par}"), None);
1300 assert_eq!(format_string("{⚙️}"), None);
1301 }
1302}
1303