dfmt 0.4.1

A fully featured dynamic template drop in replacement for the format! macro.
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

use core::fmt::Write;

use crate::{values::Specifier, ArgumentKey, Error};

#[cfg(not(feature = "std"))]
use alloc::{
    string::{String, ToString},
    vec::Vec,
};

#[derive(Debug, Clone)]
pub enum Piece {
    Literal(String),
    BracketOpen,
    BracketClose,
    Argument {
        key: ArgumentKey,
        specifier: Option<Specifier>,
    },
}

impl Piece {
    pub fn parse(input: &str) -> Result<Vec<Self>, Error> {
        let mut pieces: Vec<Piece> = Vec::with_capacity(10);

        let mut cursor = 0;
        let mut current_char = 0;
        let mut bracket = None;
        let mut separator = None;
        let mut internal_index = 0;

        let chars = input.as_bytes();
        while current_char < chars.len() {
            let char = chars[current_char];
            match char {
                b':' if bracket == Some(b'{') => {
                    if separator.is_some() {
                        return Err(Error::UnexpectedToken);
                    }

                    separator = Some(current_char);
                }
                b'{' | b'}' => match (bracket, char) {
                    (None, _) => {
                        if cursor < current_char {
                            pieces.push(Piece::Literal(input[cursor..current_char].to_string()));
                        }
                        bracket = Some(char);
                        cursor = current_char;
                    }
                    (Some(b'{'), b'}') => {
                        let specifier = if let Some(seperator_index) = separator {
                            Some(Specifier::parse(
                                &input[seperator_index + 1..current_char],
                                &mut internal_index,
                            )?)
                        } else {
                            None
                        };

                        let key = {
                            let (name_start, name_end) = match separator {
                                None => (cursor + 1, current_char),
                                Some(seperator_index) => (cursor + 1, seperator_index),
                            };

                            if name_start == name_end {
                                internal_index += 1;
                                ArgumentKey::Index(internal_index - 1)
                            } else {
                                match input[name_start..name_end].parse::<usize>() {
                                    Ok(arg_index) => ArgumentKey::Index(arg_index),
                                    Err(_) => {
                                        ArgumentKey::Name(input[name_start..name_end].to_string())
                                    }
                                }
                            }
                        };

                        pieces.push(Piece::Argument { key, specifier });

                        separator = None;
                        bracket = None;
                        cursor = current_char + 1;
                    }
                    (Some(b'{'), b'{') => {
                        pieces.push(Piece::BracketOpen);
                        bracket = None;
                        cursor = current_char + 1;
                    }
                    (Some(b'}'), b'}') => {
                        pieces.push(Piece::BracketClose);
                        bracket = None;
                        cursor = current_char + 1;
                    }
                    _ => {
                        return Err(Error::UnexpectedToken);
                    }
                },
                _ => {}
            }
            current_char += 1;
        }

        if cursor < current_char {
            pieces.push(Piece::Literal(input[cursor..current_char].to_string()));
        }

        if bracket.is_some() {
            Err(Error::UnexpectedToken)
        } else {
            Ok(pieces)
        }
    }
}

impl core::fmt::Display for Piece {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            Piece::Literal(literal) => f.write_str(literal),
            Piece::BracketOpen => f.write_str("{{"),
            Piece::BracketClose => f.write_str("}}"),
            Piece::Argument { key, specifier } => {
                f.write_char('{')?;
                write!(f, "{}", key)?;
                if let Some(specifier) = specifier {
                    f.write_char(':')?;
                    write!(f, "{}", specifier)?;
                }
                f.write_char('}')
            }
        }
    }
}