fluent-ansi 0.1.0

A fluent interface for ANSI terminal colors and styles in Rust.
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

use crate::{ColorInAPlane, Flag, Format, FormatSet, color::Color};

/// An element that can be added to a [`Format`].
///
/// This trait is used to define elements that can be added to a `Format`. Such elements
/// include flags ([`Flag`]) and colors (like [`ColorInAPlane`]).
pub trait FormatElement {
    /// Adds this element to the given `Format`, returning the updated `Format`.
    #[must_use]
    fn add_to_format(self, format: Format) -> Format;
}

/// A trait to set formatting options on a type.
///
/// This trait is implemented by types that can be formatted, such as [`Format`] and [`Formatted`](crate::Formatted).
/// It provides methods to set flags and colors, returning a type that implements [`FormatSet`].
pub trait ToFormatSet: Sized {
    /// The type that is returned by the formatting methods.
    type FormatSet: FormatSet;

    /// Sets the bold flag.
    #[must_use]
    fn bold(self) -> Self::FormatSet {
        self.flag(Flag::Bold)
    }

    /// Sets the faint flag.
    #[must_use]
    fn faint(self) -> Self::FormatSet {
        self.flag(Flag::Faint)
    }

    /// Sets the italic flag.
    #[must_use]
    fn italic(self) -> Self::FormatSet {
        self.flag(Flag::Italic)
    }

    /// Sets the underline flag.
    #[must_use]
    fn underline(self) -> Self::FormatSet {
        self.flag(Flag::Underline)
    }

    /// Sets the slow blink flag.
    #[must_use]
    fn slow_blink(self) -> Self::FormatSet {
        self.flag(Flag::SlowBlink)
    }

    /// Sets the rapid blink flag.
    #[must_use]
    fn rapid_blink(self) -> Self::FormatSet {
        self.flag(Flag::RapidBlink)
    }

    /// Sets the reverse flag.
    #[must_use]
    fn reverse(self) -> Self::FormatSet {
        self.flag(Flag::Reverse)
    }

    /// Sets the conceal flag.
    #[must_use]
    fn conceal(self) -> Self::FormatSet {
        self.flag(Flag::Conceal)
    }

    /// Sets the crossed out flag.
    #[must_use]
    fn crossed_out(self) -> Self::FormatSet {
        self.flag(Flag::CrossedOut)
    }

    /// Sets the double underline flag.
    #[must_use]
    fn double_underline(self) -> Self::FormatSet {
        self.flag(Flag::DoubleUnderline)
    }

    /// Sets the overline flag.
    #[must_use]
    fn overline(self) -> Self::FormatSet {
        self.flag(Flag::Overline)
    }

    /// Sets the given flag.
    #[must_use]
    fn flag(self, flag: Flag) -> Self::FormatSet {
        self.add(flag)
    }

    /// Sets the foreground color.
    #[must_use]
    fn fg(self, color: impl Into<Color>) -> Self::FormatSet {
        self.color(ColorInAPlane::new_in_fg(color))
    }

    /// Sets the background color.
    #[must_use]
    fn bg(self, color: impl Into<Color>) -> Self::FormatSet {
        self.color(ColorInAPlane::new_in_bg(color))
    }

    /// Sets the given color in a plane.
    #[must_use]
    fn color(self, color_in_a_plane: ColorInAPlane) -> Self::FormatSet {
        self.add(color_in_a_plane)
    }

    /// Adds the given element to the formatting.
    #[must_use]
    fn add(self, element: impl FormatElement) -> Self::FormatSet {
        self.to_format_set().add(element)
    }

    /// Converts this value to a format set.
    #[must_use]
    fn to_format_set(self) -> Self::FormatSet;
}