core-dev 0.0.1

core-dev library is an utility library for rust. It contains a lot of useful functions and APIs to speed up development cycle.
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

use ansi_term::Colour::{
    Black,
    Red,
    Green,
    Yellow,
    Blue,
    Purple,
    Cyan,
    Fixed,
    RGB,
};
use hex_color::HexColor;
use ansi_term::Style;

use ansi_hex_color::colored as hex_colored;

use std::thread::sleep;
use std::time::Duration;

use std::io::stdout;
use std::io::Write;

use std::error;
use std::result;

use std::thread;
use std::fmt;

#[derive(Debug)]
pub struct SpinnerClosureError;

// https://learning-rust.github.io/docs/e7.custom_error_types.html
// https://www.philipdaniels.com/blog/2019/defining-rust-error-types/
impl error::Error for SpinnerClosureError {
    fn description(&self) -> &str {
        "something went wrong inside the closure"
    }
}


impl fmt::Display for SpinnerClosureError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "something went wrong inside the closure")
    }
}


type SpinnerClosure<T> = Box<dyn FnOnce() -> T + Send + 'static>;
type SpinnerClosureResult<T> = result::Result<T, SpinnerClosureError>;

// https://stackoverflow.com/questions/25649423/sending-trait-objects-between-threads-in-rust
pub struct SpinnerDotsThread<'a, T>
where
    T: Send + 'static, {
    frames:              [&'a str; 10],
    _function:           SpinnerClosure<T>,
    message:             String,
    termination_message: String,
}

impl<'a, T> SpinnerDotsThread<'a, T>
where
    T: Send + 'static,
{
    pub fn new(
        message: String,
        _function: SpinnerClosure<T>,
        termination_message: String,
    ) -> SpinnerDotsThread<'a, T> {
        SpinnerDotsThread {
            frames: [
                "⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏",
            ],
            _function,
            message,
            termination_message,
        }
    }

    pub fn run_default(
        _function: SpinnerClosure<T>,
    ) -> SpinnerClosureResult<T> {
        let yellow_package = Yellow.paint("📦");
        let green_successfully = Green.paint("successfully");
        let running_message =
            format!("{yellow_package} loading ... ");
        let termination_message = format!(
            "{yellow_package} terminated {green_successfully}"
        );

        SpinnerDotsThread::run_with_args(
            running_message,
            _function,
            termination_message,
        )
    }

    pub fn run_with_args(
        message: String,
        _function: SpinnerClosure<T>,
        termination_message: String,
    ) -> SpinnerClosureResult<T> {
        let spinner = SpinnerDotsThread::new(
            message,
            _function,
            termination_message,
        );
        spinner.execute()
    }

    pub fn execute(self) -> SpinnerClosureResult<T> {
        let handle = thread::spawn(move || (self._function)());

        // very nice color: #2666
        // let cyan: HexColor = "#999999".parse().unwrap();
        // let cyan = RGB(cyan.r, cyan.g, cyan.b);
        let mut _iter = 0;
        while !handle.is_finished() {
            let frame = self.frames[_iter % 10];
            let frame = Yellow.paint(frame);
            print!("{} {}\r", frame, self.message);
            stdout().flush().expect("some error message");
            sleep(Duration::from_millis(50));
            _iter += 1;
        }
        println!("{}", self.termination_message);
        let result = handle.join();
        match result {
            Ok(result) => Ok(result),
            Err(err) => Err(SpinnerClosureError),
        }
    }
}