clml-proc-macro 0.2.0

Implementation for the package clml
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! This internal library provides the procedural macros needed by the crate [`clml`].
//!
//! [`clml`]: https://crates.io/crates/clml

extern crate proc_macro;

#[macro_use]
mod util;
mod ansi;
mod ansi_constants;
mod color_context;
mod error;
mod format_args;
mod parse;
mod untagged;

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::{ToTokens, quote};
use syn::parse::{Parse, ParseStream};
use syn::token::Comma;
use syn::{Expr, parse_macro_input};

/// The same as `format!()`, but parses color tags.
///
/// #### Example
///
/// ```
/// # use clml_proc_macro::cformat;
/// let s: String = cformat!("A <g>green</> word, {}", "placeholders are allowed");
/// assert_eq!(s, "A \u{1b}[32mgreen\u{1b}[39m word, placeholders are allowed");
/// ```
#[proc_macro]
pub fn cformat(input: TokenStream) -> TokenStream {
    get_macro("format", input, false)
}

/// The same as `write!()`, but parses color tags.
#[proc_macro]
pub fn cwrite(input: TokenStream) -> TokenStream {
    get_macro("write", input, true)
}

/// The same as `writeln!()`, but parses color tags.
#[proc_macro]
pub fn cwriteln(input: TokenStream) -> TokenStream {
    get_macro("writeln", input, true)
}

/// The same as `cformat!()`, but also dedents the format string like `indoc::indoc!()`.
#[cfg(feature = "doc")]
#[proc_macro]
pub fn cformatdoc(input: TokenStream) -> TokenStream {
    get_macro_doc("format", input, false)
}

/// The same as `cwrite!()`, but also dedents the format string like `indoc::indoc!()`.
#[cfg(feature = "doc")]
#[proc_macro]
pub fn cwritedoc(input: TokenStream) -> TokenStream {
    get_macro_doc("write", input, true)
}

/// The same as `cwriteln!()`, but also dedents the format string like `indoc::indoc!()`.
#[cfg(feature = "doc")]
#[proc_macro]
pub fn cwritelndoc(input: TokenStream) -> TokenStream {
    get_macro_doc("writeln", input, true)
}

/// Colorizes a string literal, without formatting the `format!`-like placeholders.
///
/// Accepts only one argument.
///
/// #### Example
///
/// ```
/// # use clml_proc_macro::cstr;
/// let s: &str = cstr!("A <g>green</> word");
/// assert_eq!(s, "A \u{1b}[32mgreen\u{1b}[39m word");
/// ```
#[proc_macro]
pub fn cstr(input: TokenStream) -> TokenStream {
    crate::ansi::get_cstr(input)
        .unwrap_or_else(|err| err.to_token_stream())
        .into()
}

/// Removes all the color tags from the given string literal.
///
/// Accepts only one argument.
///
/// #### Example
///
/// ```
/// # use clml_proc_macro::untagged;
/// let s: &str = untagged!("A <g>normal</> word");
/// assert_eq!(s, "A normal word");
/// ```
#[proc_macro]
pub fn untagged(input: TokenStream) -> TokenStream {
    crate::untagged::get_untagged(input)
        .unwrap_or_else(|err| err.to_token_stream())
        .into()
}

struct WriteInput {
    dst: Expr,
    rest: TokenStream,
}

impl Parse for WriteInput {
    fn parse(input: ParseStream) -> syn::parse::Result<Self> {
        let dst: Expr = input.parse()?;
        let _: Comma = input.parse()?;
        // Forward the tail as raw tokens: it is re-parsed as `format!`-like arguments downstream,
        // so parsing it as expressions here would only round-trip it for no benefit.
        let rest = input.parse::<TokenStream2>()?.into();
        Ok(Self { dst, rest })
    }
}

/// Renders a whole processed macro.
fn get_macro(macro_name: &str, input: TokenStream, is_write_macro: bool) -> TokenStream {
    get_macro_impl(
        macro_name,
        input,
        is_write_macro,
        crate::ansi::get_format_args,
    )
}

/// Same as [`get_macro`], but the format string is dedented like `indoc::indoc!()`.
#[cfg(feature = "doc")]
fn get_macro_doc(macro_name: &str, input: TokenStream, is_write_macro: bool) -> TokenStream {
    get_macro_impl(
        macro_name,
        input,
        is_write_macro,
        crate::ansi::get_format_args_doc,
    )
}

fn get_macro_impl(
    macro_name: &str,
    input: TokenStream,
    is_write_macro: bool,
    get_format_args: fn(TokenStream) -> Result<TokenStream2, crate::error::SpanError>,
) -> TokenStream {
    let macro_name = util::ident(macro_name);
    let fmt_args =
        |input_tail| get_format_args(input_tail).unwrap_or_else(|err| err.to_token_stream());

    if is_write_macro {
        let WriteInput { dst, rest } = parse_macro_input!(input);
        let format_args = fmt_args(rest);
        (quote! { #macro_name!(#dst, #format_args) }).into()
    } else {
        let format_args = fmt_args(input);
        (quote! { #macro_name!(#format_args) }).into()
    }
}