sayaka 0.2.1

some simple colorful debugging functions
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

use std::env;

use colored::Colorize;
use once_cell::sync::Lazy;

pub const SAYAKA_DEBUG: Lazy<bool> = Lazy::new(|| match env::var("SAYAKA_DEBUG") {
    Ok(value) => {
        if value.parse::<u8>().unwrap() > 0 {
            true
        } else {
            false
        }
    }
    Err(_) => false,
});

pub const SAYAKA_NO_COLOR: Lazy<bool> = Lazy::new(|| match env::var("SAYAKA_NO_COLOR") {
    Ok(value) => {
        if value.parse::<u8>().unwrap() > 0 {
            true
        } else {
            false
        }
    }
    Err(_) => false,
});

pub fn log_debug(colored: bool, file: &'static str, line: u32) {
    let now = chrono::Local::now();
    let timestamp = now.format("%Y-%m-%d %H:%M:%S").to_string();
    if colored {
        eprint!(
            "[{}][{}][{}]",
            "DEBUG".green(),
            timestamp.yellow(),
            format!("{}:{}", file, line).cyan()
        );
    } else {
        eprint!(
            "[{}][{}][{}]",
            "DEBUG",
            timestamp,
            format!("{}:{}", file, line)
        );
    }
}

// For external package macro
#[macro_export]
macro_rules! debugln {
    ($($arg:tt)*) => {{
        if *sayaka::debugger::SAYAKA_DEBUG {
            if *sayaka::debugger::SAYAKA_NO_COLOR {
                sayaka::debugger::log_debug(false, file!(), line!());
            } else {
                sayaka::debugger::log_debug(true, file!(), line!());
            }
            eprint!(" ");
            eprintln!($($arg)*);
        }
    }};
}

#[macro_export]
macro_rules! debug_fn {
    ($($expression:expr), *) => {
        fn f() {}
        fn type_name_of<T>(_: T) -> &'static str {
            std::any::type_name::<T>()
        }
        let name = type_name_of(f);
        if *sayaka::debugger::SAYAKA_DEBUG {
            if *sayaka::debugger::SAYAKA_NO_COLOR {
                sayaka::debugger::log_debug(false,file!(),line!());
            } else {
                sayaka::debugger::log_debug(true,file!(),line!());
            }
            eprint!(" Calling {}(),", name.strip_suffix("::f").unwrap());
            $(
                {
                    eprint!(" {:?} = {:?}", stringify!($expression), &$expression);
                }
            )*
            eprintln!();
        }
    };
}

#[macro_export]
macro_rules! debug_var {
    ($($expression:expr), *) => (
        if *sayaka::debugger::SAYAKA_DEBUG {
            $(
                {
                    if *sayaka::debugger::SAYAKA_NO_COLOR {
                        sayaka::debugger::log_debug(false, file!(), line!());
                    } else {
                        sayaka::debugger::log_debug(true, file!(), line!());
                    }
                    eprint!(" ");
                    eprint!("{:?} = {:#?}",stringify!($expression),&$expression);
                    eprintln!();
                }
            )*
        }
    )
}