opaline 0.4.1

A token-based theme engine for Rust applications
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

//! owo-colors adapter — zero-allocation terminal coloring.
//!
//! Provides conversion from [`OpalineStyle`] to [`owo_colors::Style`] and
//! an extension trait for applying theme colors to any displayable type.
//!
//! ```rust,ignore
//! use opaline::adapters::owo_colors::OwoThemeExt;
//!
//! let theme = Theme::default();
//! println!("{}", "hello".style(theme.owo_style("keyword")));
//! ```

use owo_colors::Style;

use crate::style::OpalineStyle;
use crate::theme::Theme;
#[cfg(feature = "gradients")]
use unicode_segmentation::UnicodeSegmentation;

// ═══════════════════════════════════════════════════════════════════════════════
// Style conversion
// ═══════════════════════════════════════════════════════════════════════════════

impl From<OpalineStyle> for Style {
    fn from(s: OpalineStyle) -> Self {
        build_owo_style(&s)
    }
}

impl From<&OpalineStyle> for Style {
    fn from(s: &OpalineStyle) -> Self {
        build_owo_style(s)
    }
}

fn build_owo_style(s: &OpalineStyle) -> Style {
    let mut style = Style::new();

    if let Some(fg) = s.fg {
        style = style.truecolor(fg.r, fg.g, fg.b);
    }
    if let Some(bg) = s.bg {
        style = style.on_truecolor(bg.r, bg.g, bg.b);
    }
    if s.bold {
        style = style.bold();
    }
    if s.dim {
        style = style.dimmed();
    }
    if s.italic {
        style = style.italic();
    }
    if s.underline {
        style = style.underline();
    }
    if s.slow_blink || s.rapid_blink {
        style = style.blink();
    }
    if s.reversed {
        style = style.reversed();
    }
    if s.hidden {
        style = style.hidden();
    }
    if s.crossed_out {
        style = style.strikethrough();
    }

    style
}

// ═══════════════════════════════════════════════════════════════════════════════
// Theme extension
// ═══════════════════════════════════════════════════════════════════════════════

/// Extension trait for themed owo-colors output on [`Theme`].
pub trait OwoThemeExt {
    /// Build an [`owo_colors::Style`] from a named theme style.
    fn owo_style(&self, style_name: &str) -> Style;

    /// Build an [`owo_colors::Style`] with a token color as foreground.
    fn owo_fg(&self, token: &str) -> Style;

    /// Build an [`owo_colors::Style`] with a token color as background.
    fn owo_bg(&self, token: &str) -> Style;
}

impl OwoThemeExt for Theme {
    fn owo_style(&self, style_name: &str) -> Style {
        Style::from(self.style(style_name))
    }

    fn owo_fg(&self, token: &str) -> Style {
        let c = self.color(token);
        Style::new().truecolor(c.r, c.g, c.b)
    }

    fn owo_bg(&self, token: &str) -> Style {
        let c = self.color(token);
        Style::new().on_truecolor(c.r, c.g, c.b)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// Gradient helpers
// ═══════════════════════════════════════════════════════════════════════════════

/// Render a string with per-character gradient coloring as an ANSI string.
///
/// Uses owo-colors for zero-allocation formatting of each character.
#[cfg(feature = "gradients")]
pub fn gradient_string(text: &str, gradient: &crate::gradient::Gradient) -> String {
    use owo_colors::OwoColorize as _;
    use std::fmt::Write as _;

    let graphemes: Vec<&str> = text.graphemes(true).collect();
    if graphemes.is_empty() {
        return String::new();
    }

    let colors = gradient.generate(graphemes.len());
    let mut result = String::with_capacity(text.len() * 20);

    for (grapheme, color) in graphemes.into_iter().zip(colors) {
        let _ = write!(result, "{}", grapheme.truecolor(color.r, color.g, color.b));
    }

    result
}