termint 0.8.1

Library for colored printing and Terminal User Interfaces
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

/// Macro to combine [`Border`](crate::enums::Border) sides
///
/// ## Usage:
/// ```rust
/// # use termint::{borders, enums::Border};
/// // Without macro:
/// let top_left_right = Border::TOP | Border::LEFT | Border::RIGHT;
/// // With macro:
/// let top_left_right = borders!(TOP, LEFT, RIGHT);
/// ```
#[macro_export]
macro_rules! borders {
    ($($side:ident),* $(,)?) => {
        $crate::enums::Border::NONE $(| $crate::enums::Border::$side)*
    };
}

/// Makes creating help easier
///
/// ### Header:
/// - Printed in green
/// ```ignore
/// "header":
/// ```
///
/// ### Command help:
/// - Command is printed in yellow and has left padding of 2
/// - Others in default color
/// - Description has left padding of 4
/// ```ignore
/// // One description literals
/// "command" ["params"]* => "description"
/// // Multiple description literals
/// "command" ["params"]* => {
///     "description1",
///     "description2"
/// }
/// ```
///
/// ## Usage:
/// ```rust
/// # use termint::{enums::Color, help, widgets::ToSpan};
/// help!(
///     "Usage":
///     "-t" ["value"] => "Tests program with [value]"
///     "-d" => {
///         "Creates documentation",
///         "When used with -t, also tests the documentation",
///     }
///     "Special case":
///     "-ntd" => "Creates documentation and runs test without testing docs"
/// );
/// ```
#[macro_export]
macro_rules! help {
    // Rule for parsing header
    ($header:literal: $($rest:tt)*) => {
        println!(
            "{}:",
            $crate::widgets::Span::new($header).fg($crate::enums::Color::Green)
        );
        help!($($rest)*);
    };

    // Rule for parsing command help without curly braces
    (
        $cmd:literal $([$param:literal])* => $description:literal
        $($rest:tt)*
    ) => {
        print!(
            "  {}",
            $crate::widgets::Span::new($cmd).fg($crate::enums::Color::Yellow)
        );
        $(print!(" [{}]", $param);)*
        println!();
        println!("    {}", $description);
        help!($($rest)*);
    };

    // Rule for parsing command help with curly braces
    (
        $cmd:literal $([$param:literal])* => {
            $($description:literal),* $(,)?
        }
        $($rest:tt)*
    ) => {
        print!(
            "  {}",
            $crate::widgets::Span::new($cmd).fg($crate::enums::Color::Yellow)
        );
        $(print!(" [{}]", $param);)*
        println!();
        $(println!("    {}", $description);)*
        help!($($rest)*);
    };

    () => {};
}

/// Creates vector with given given Modifiers
///
/// ## Usage:
/// ```rust
/// # use termint::{enums::Modifier, modifiers};
/// // Without macro:
/// let mods = Modifier::BOLD | Modifier::ITALIC;
/// // With macro:
/// let mods = modifiers!(BOLD, ITALIC);
/// ```
#[macro_export]
macro_rules! modifiers {
    ($($mod:ident),* $(,)?) => {
        $crate::enums::Modifier::NONE $(| $crate::enums::Modifier::$mod)*
    };
}

/// Creates new paragraph in simpler way, when using heterogeneous types.
///
/// ## Usage:
/// ```rust
/// use termint::{prelude::*, paragraph, text::Text, widgets::Grad};
///
/// // Without macro using multiple types
/// let items: Vec<Box<dyn Text>> = vec![
///     Box::new("Paragraph".to_span()),
///     Box::new("macro".fg(Color::Red)),
///     Box::new(Grad::new("showcase", (0, 0, 255), (0, 255, 0)))
/// ];
/// let p = Paragraph::new(items);
///
/// // With macro:
/// let p = paragraph!(
///     "Paragraph",
///     "macro".fg(Color::Red),
///     Grad::new("showcase", (0, 0, 255), (0, 255, 0))
/// );
/// ```
#[macro_export]
macro_rules! paragraph {
    ($($text:expr),* $(,)?) => {
        $crate::widgets::Paragraph::new(vec![
            $({
                let t: Box<dyn $crate::text::Text> = $text.into();
                t
            }),*
        ])
    };
}