flogging_macros/src/format.rs

Lines

100.00 %

Functions

100.00 %

Regions

100.00 %


//
// File Name:    fmt_log.rs
// Project Name: flogging
//
// Copyright (C) 2025 Bradley Willcott
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
// This library (crate) is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This library (crate) is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this library (crate).  If not, see <https://www.gnu.org/licenses/>.
//

//!
//! # format Macro Impl
//!
//! Format the Log function call (Rust code)
//!

use dyn_fmt::AsStrFormatExt;
use proc_macro::TokenStream;
use regex::RegexBuilder;

pub(crate) fn format_impl(fmt_str: &str, msg: TokenStream) -> TokenStream {
    // println!("msg: {}", &msg);

    let fmt = "let __fmt = format!({});\n".format(&[
        match process_msg(msg){
            Some(r_msg) => r_msg,
            None => return TokenStream::new(),
        }
        ]);

    let mut buf = String::new();
    buf.push_str(&fmt);
    buf.push_str(fmt_str);

    // let rtn = buf.parse().unwrap_or_default();
    // println!("{rtn}");
    // rtn
    buf.parse().unwrap_or_default()
}
///
/// Check for `object` only `msg`.
///
/// If found, provide default format string.
///
fn process_msg(msg: TokenStream) -> Option<String> {
    let text = msg.to_string();

    if text.is_empty() {
        return None;
    }

    if text.starts_with('\"') && text.ends_with('\"') {
        return Some(text);
    }

    let regex_str = "(?<fmt>\".*\\{.*\\}.*\")(,[\\s]*(?<attrs>.*)*)";

    let re = RegexBuilder::new(regex_str)
        .dot_matches_new_line(true)
        .build()
        .unwrap();

    if re.is_match(&text) {
        Some(text)
    } else {
        let count = text.split(',').count();

        let mut buf = String::new();

        if count == 1 {
            buf.push_str("\"{}\", ");
        } else {
            buf.push_str("\"{}");

            for _i in 1..count {
                buf.push_str(", {}");
            }

            buf.push_str("\", ");
        }

        buf.push_str(&text);

        Some(buf)
    }
}

Line	Count	Source
1		//
2		// File Name: fmt_log.rs
3		// Project Name: flogging
4		//
5		// Copyright (C) 2025 Bradley Willcott
6		//
7		// SPDX-License-Identifier: GPL-3.0-or-later
8		//
9		// This library (crate) is free software: you can redistribute it and/or modify
10		// it under the terms of the GNU General Public License as published by
11		// the Free Software Foundation, either version 3 of the License, or
12		// (at your option) any later version.
13		//
14		// This library (crate) is distributed in the hope that it will be useful,
15		// but WITHOUT ANY WARRANTY; without even the implied warranty of
16		// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		// GNU General Public License for more details.
18		//
19		// You should have received a copy of the GNU General Public License
20		// along with this library (crate). If not, see <https://www.gnu.org/licenses/>.
21		//
22
23		//!
24		//! # format Macro Impl
25		//!
26		//! Format the Log function call (Rust code)
27		//!
28
29		use dyn_fmt::AsStrFormatExt;
30		use proc_macro::TokenStream;
31		use regex::RegexBuilder;
32
33	33	pub(crate) fn format_impl(fmt_str: &str, msg: TokenStream) -> TokenStream {
34		// println!("msg: {}", &msg);
35
36	32	let fmt = "let __fmt = format!({});\n".format(&[
37	33	match process_msg(msg){
38	32	Some(r_msg) => r_msg,
39	1	None => return TokenStream::new(),
40		}
41		]);
42
43	32	let mut buf = String::new();
44	32	buf.push_str(&fmt);
45	32	buf.push_str(fmt_str);
46
47		// let rtn = buf.parse().unwrap_or_default();
48		// println!("{rtn}");
49		// rtn
50	32	buf.parse().unwrap_or_default()
51	33	}
52		///
53		/// Check for `object` only `msg`.
54		///
55		/// If found, provide default format string.
56		///
57	33	fn process_msg(msg: TokenStream) -> Option<String> {
58	33	let text = msg.to_string();
59
60	33	if text.is_empty() {
61	1	return None;
62	32	}
63
64	28	if text.starts_with('\"') && text.ends_with('\"') {
65	19	return Some(text);
66	13	}
67
68	13	let regex_str = "(?<fmt>\".\\{.\\}.\")(,[\\s](?<attrs>.))";
69
70	13	let re = RegexBuilder::new(regex_str)
71	13	.dot_matches_new_line(true)
72	13	.build()
73	13	.unwrap();
74
75	13	if re.is_match(&text) {
76	9	Some(text)
77		} else {
78	4	let count = text.split(',').count();
79
80	4	let mut buf = String::new();
81
82	3	if count == 1 {
83	3	buf.push_str("\"{}\", ");
84	3	} else {
85	1	buf.push_str("\"{}");
86
87	2	for _i in 1..count {
88	2	buf.push_str(", {}");
89	2	}
90
91	1	buf.push_str("\", ");
92		}
93
94	4	buf.push_str(&text);
95
96	4	Some(buf)
97		}
98	33	}