exact_format 0.2.1

A procedural macro for compile time string replacement without using the standard format placeholder syntax (`{}`). This is most useful when dealing with strings that contain `{ }` blocks you do no wish to interpolate e.g. writing javascript.
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

#![doc = include_str!("../README.md")]

use proc_macro::TokenStream;
use quote::{ToTokens, quote};
use syn::{
    Expr, Ident, LitStr, Token,
    parse::{Parse, ParseStream},
    parse_macro_input,
    punctuated::Punctuated,
    spanned::Spanned,
};

struct ExactFormat {
    template: LitStr,
    replacements: Punctuated<Replacement, Token![,]>,
}

struct Replacement {
    from: LitStr,
    _arrow: Token![=>],
    to: Expr,
}

/// Enum to represent either a string literal part or a replacement value
enum FormatPart {
    Literal(String),
    Value(Ident),
}

impl Parse for Replacement {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let from = input.parse()?;
        let _arrow = input.parse()?;
        let to = input.parse()?;

        Ok(Replacement { from, _arrow, to })
    }
}

impl Parse for ExactFormat {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let template = input.parse()?;
        let _: Token![,] = input.parse()?;

        let replacements = Punctuated::parse_terminated(input)?;

        Ok(ExactFormat {
            template,
            replacements,
        })
    }
}

impl ToTokens for FormatPart {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        match self {
            FormatPart::Literal(s) => {
                let lit = syn::LitStr::new(s, proc_macro2::Span::call_site());
                lit.to_tokens(tokens);
            }
            FormatPart::Value(expr) => {
                expr.to_tokens(tokens);
            }
        }
    }
}

/// Macro to replace placeholders in a string with values at compile time.
#[proc_macro]
pub fn exact_format(input: TokenStream) -> TokenStream {
    let ExactFormat {
        template,
        replacements,
    } = parse_macro_input!(input as ExactFormat);

    let mut parts = vec![FormatPart::Literal(template.value())];
    let mut values = Vec::new();

    for (index, replacement) in replacements.iter().enumerate() {
        let key = replacement.from.value();
        let value = &replacement.to;
        let value_name = format!("__value{}__", index);
        let value_ident = syn::Ident::new(&value_name, value.span());
        values.push(quote! { let #value_ident = #value; });

        let mut new_parts = Vec::new();

        for part in parts {
            match part {
                FormatPart::Literal(text) => {
                    if text.contains(&key) {
                        let split_parts: Vec<&str> = text.split(&key).collect();

                        for (i, split_part) in split_parts.iter().enumerate() {
                            if !split_part.is_empty() {
                                new_parts.push(FormatPart::Literal(split_part.to_string()));
                            }

                            if i < split_parts.len() - 1 {
                                new_parts.push(FormatPart::Value(value_ident.clone()));
                            }
                        }
                    } else {
                        new_parts.push(FormatPart::Literal(text));
                    }
                }
                FormatPart::Value(expr) => {
                    new_parts.push(FormatPart::Value(expr));
                }
            }
        }

        parts = new_parts;
    }

    let expanded = if parts.is_empty() {
        quote! { { #(#values)* #template.to_string() } }
    } else {
        let format_str = "{}".repeat(parts.len());
        let format_lit = syn::LitStr::new(&format_str, proc_macro2::Span::call_site());
        quote! { { #(#values)* format!(#format_lit, #(#parts),*) } }
    };

    expanded.into()
}