randsym 0.1.1

Generates unique identifiers for macros
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

//! # `randsym`
//!
//! Creates unique identifiers for macros.
//!
//! [![github]](https://github.com/DexterHill0/randsym) [![crates-io]](https://crates.io/crates/randsym) [![docs-rs]](https://docs.rs/randsym)
//!
//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
//!
//! `randsym` generates unique identifiers using UUID. The identifies can be used simply to avoid two items with the same identifier, or they can be bound to names allowing the identifiers to be repeated.
//!
//! The syntax is as follows:
//! - `/?/` - random identifier
//! - `/?@the_ident/` - random identifier bound to the name `the_ident`
//!
//! ### Examples:
//! **No binding**
//! ```rs
//! randsym::randsym! {
//!     fn /?/ () -> String {
//!         "I have a random name!".into()
//!     }
//! }
//! ```
//!
//! **With binding**
//! ```rs
//! randsym::randsym! {
//!     fn /?@my_fn/ () -> String {
//!         "I have a random name!".into()
//!     }
//!
//!     println!("{}", /?@my_fn/()); // "I have a random name!"
//! }
//! ```

use std::collections::HashMap;

use proc_macro::{TokenTree as TT, *};
use uuid::Uuid;

/// Generates a random identifier.
///
/// ```
/// randsym::randsym! {
///     fn /?/ () -> String {
///         "I have a random name!".into()
///     }
/// }
/// ```
/// ------
/// ```
/// randsym::randsym! {
///     fn /?@my_fn/ () -> String {
///         "I have a random name!".into()
///     }
///
///     println!("{}", /?@my_fn/()); // "I have a random name!"
/// }
/// ```
fn replace_syms(tokens: TokenStream, named_syms: &mut HashMap<String, Ident>) -> TokenStream {
    let mut tokens = tokens.into_iter().peekable();
    let mut out = TokenStream::new();

    loop {
        out.extend(Some(match tokens.next() {
            Some(ref p1 @ TT::Punct(ref punct)) if punct.as_char() == '/' => match tokens.peek() {
                Some(TT::Punct(ref punct)) if punct.as_char() == '?' => {
                    let p2 = tokens.next().unwrap();

                    match tokens.peek() {
                        Some(TT::Punct(punct)) if punct.as_char() == '@' => {
                            tokens.next();

                            match tokens.next() {
                                Some(TT::Ident(name)) => {
                                    let name =
                                        named_syms.entry(name.to_string()).or_insert_with(gen_sym);

                                    match tokens.next() {
                                        Some(TT::Punct(ref punct)) if punct.as_char() == '/' => {
                                            TT::Ident(name.clone())
                                        }
                                        Some(tok) => tok,
                                        None => break,
                                    }
                                }
                                Some(tok) => tok,
                                None => break,
                            }
                        }
                        Some(TT::Punct(punct)) if punct.as_char() == '/' => {
                            tokens.next();

                            TT::Ident(gen_sym())
                        }
                        _ => p2,
                    }
                }
                _ => p1.clone(),
            },
            Some(TT::Group(group)) => {
                Group::new(group.delimiter(), replace_syms(group.stream(), named_syms)).into()
            }
            Some(tok) => tok,
            None => break,
        }))
    }

    out
}

#[proc_macro]
pub fn randsym(input: TokenStream) -> TokenStream {
    let mut named_syms = HashMap::new();

    replace_syms(input, &mut named_syms)
}

// generate random ident using simple uuid
fn gen_sym() -> Ident {
    Ident::new(
        &format!("_randsym_{}", Uuid::new_v4().simple()),
        Span::call_site(),
    )
}