cornelli 1.4.2

Write to your future self.
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

// SPDX-License-Identifier: MIT OR Apache-2.0

//! logger module for cutler.
//!
//! Use the log_*! macros for pretty-printing text inside cutler.

use std::{
    io::{self, Write},
    thread::sleep,
    time::Duration,
};

// ANSI color codes.
const RED: &str = "\x1b[31m";
const RESET: &str = "\x1b[0m";

#[doc(hidden)]
#[derive(PartialEq, Eq)]
pub enum LogLevel {
    Error,
    Orb,
    Sparkles,
    Letter,
}

#[doc(hidden)]
pub fn _print_log(level: LogLevel, msg: &str) {
    let tag = match level {
        LogLevel::Error => "Oh no!",
        LogLevel::Sparkles => "✨️",
        LogLevel::Orb => "🔮",
        LogLevel::Letter => "💌",
    };

    let line = if level == LogLevel::Error {
        format!("{RED}{tag}{RESET} {msg}")
    } else {
        format!("{tag} {msg}")
    };

    if level == LogLevel::Error {
        eprintln!("{line}");
    } else if level == LogLevel::Orb {
        type_out(&line.to_string(), 20, true);
    } else if level == LogLevel::Sparkles {
        type_out(&line.to_string(), 20, false);
    } else {
        type_out(&line.to_string(), 100, false);
    }
}

fn type_out(s: &str, ms: u64, dot: bool) {
    let mut out = io::stdout();
    let dur = Duration::from_millis(ms);

    for c in s.chars() {
        out.write_all(c.to_string().as_bytes()).unwrap_or_default();
        out.flush().unwrap_or_default();
        sleep(dur);
    }

    if dot {
        let dot_dur = dur * 4;
        for _ in 0..3 {
            write!(out, ".").ok();
            out.flush().ok();
            sleep(dot_dur);
            write!(out, ".").ok();
            out.flush().ok();
            sleep(dot_dur);
            write!(out, "\x08 \x08\x08 \x08").ok();
            out.flush().ok();
            sleep(dot_dur);
        }
    }

    println!()
}

/// Logs with `LogLevel::Error`.
#[macro_export]
macro_rules! log_err {
    ($($arg:tt)*) => {{
        let msg = format!($($arg)*);
        $crate::utils::logger::_print_log($crate::utils::logger::LogLevel::Error, &msg);
    }};
}

/// Logs with `LogLevel::Sparkles`.
#[macro_export]
macro_rules! log_sparkles {
    ($($arg:tt)*) => {{
        let msg = format!($($arg)*);
        $crate::utils::logger::_print_log($crate::utils::logger::LogLevel::Sparkles, &msg);
    }};
}

/// Logs with `LogLevel::Orb`.
#[macro_export]
macro_rules! log_orb {
    ($($arg:tt)*) => {{
        let msg = format!($($arg)*);
        $crate::utils::logger::_print_log($crate::utils::logger::LogLevel::Orb, &msg);
    }};
}

/// Logs with `LogLevel::Letter`.
#[macro_export]
macro_rules! log_letter {
    ($($arg:tt)*) => {{
        let msg = format!($($arg)*);
        $crate::utils::logger::_print_log($crate::utils::logger::LogLevel::Letter, &msg);
    }};
}