loaders 0.0.0

//! ANSI color support implemented without external dependencies.

use crate::terminal::detect::{ColorSupport, color_support};

/// An ANSI foreground or background color.
///
/// Use the named variants for portable sixteen-color output, `Color256` for
/// indexed color, or `Rgb` for true color capable terminals.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub enum Color {
    /// ANSI black.
    Black,
    /// ANSI red.
    Red,
    /// ANSI green.
    Green,
    /// ANSI yellow.
    Yellow,
    /// ANSI blue.
    Blue,
    /// ANSI magenta.
    Magenta,
    /// ANSI cyan.
    Cyan,
    /// ANSI white.
    White,
    /// Bright black / gray.
    BrightBlack,
    /// Bright red.
    BrightRed,
    /// Bright green.
    BrightGreen,
    /// Bright yellow.
    BrightYellow,
    /// Bright blue.
    BrightBlue,
    /// Bright magenta.
    BrightMagenta,
    /// Bright cyan.
    BrightCyan,
    /// Bright white.
    BrightWhite,
    /// ANSI 256-color palette index.
    Color256(u8),
    /// True-color RGB.
    Rgb(u8, u8, u8),
}

impl Color {
    /// Renders this color as a foreground ANSI code.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert_eq!(loaders::Color::Red.render_fg(), "\x1b[31m");
    /// ```
    pub fn render_fg(&self) -> String {
        match self {
            Self::Black => "\x1b[30m".to_string(),
            Self::Red => "\x1b[31m".to_string(),
            Self::Green => "\x1b[32m".to_string(),
            Self::Yellow => "\x1b[33m".to_string(),
            Self::Blue => "\x1b[34m".to_string(),
            Self::Magenta => "\x1b[35m".to_string(),
            Self::Cyan => "\x1b[36m".to_string(),
            Self::White => "\x1b[37m".to_string(),
            Self::BrightBlack => "\x1b[90m".to_string(),
            Self::BrightRed => "\x1b[91m".to_string(),
            Self::BrightGreen => "\x1b[92m".to_string(),
            Self::BrightYellow => "\x1b[93m".to_string(),
            Self::BrightBlue => "\x1b[94m".to_string(),
            Self::BrightMagenta => "\x1b[95m".to_string(),
            Self::BrightCyan => "\x1b[96m".to_string(),
            Self::BrightWhite => "\x1b[97m".to_string(),
            Self::Color256(n) => format!("\x1b[38;5;{n}m"),
            Self::Rgb(r, g, b) => format!("\x1b[38;2;{r};{g};{b}m"),
        }
    }

    /// Renders this color as a background ANSI code.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert_eq!(loaders::Color::Blue.render_bg(), "\x1b[44m");
    /// ```
    pub fn render_bg(&self) -> String {
        match self {
            Self::Black => "\x1b[40m".to_string(),
            Self::Red => "\x1b[41m".to_string(),
            Self::Green => "\x1b[42m".to_string(),
            Self::Yellow => "\x1b[43m".to_string(),
            Self::Blue => "\x1b[44m".to_string(),
            Self::Magenta => "\x1b[45m".to_string(),
            Self::Cyan => "\x1b[46m".to_string(),
            Self::White => "\x1b[47m".to_string(),
            Self::BrightBlack => "\x1b[100m".to_string(),
            Self::BrightRed => "\x1b[101m".to_string(),
            Self::BrightGreen => "\x1b[102m".to_string(),
            Self::BrightYellow => "\x1b[103m".to_string(),
            Self::BrightBlue => "\x1b[104m".to_string(),
            Self::BrightMagenta => "\x1b[105m".to_string(),
            Self::BrightCyan => "\x1b[106m".to_string(),
            Self::BrightWhite => "\x1b[107m".to_string(),
            Self::Color256(n) => format!("\x1b[48;5;{n}m"),
            Self::Rgb(r, g, b) => format!("\x1b[48;2;{r};{g};{b}m"),
        }
    }
}

/// A complete ANSI style specification.
///
/// Styles are builder-friendly and can be applied to arbitrary text with
/// `render`.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ColorSpec {
    /// Optional foreground color.
    pub fg: Option<Color>,
    /// Optional background color.
    pub bg: Option<Color>,
    /// Bold text.
    pub bold: bool,
    /// Dim text.
    pub dim: bool,
    /// Italic text.
    pub italic: bool,
    /// Underlined text.
    pub underline: bool,
    /// Blinking text.
    pub blink: bool,
    /// Reverse foreground and background.
    pub reverse: bool,
    /// Strikethrough text.
    pub strikethrough: bool,
}

impl ColorSpec {
    /// Creates an empty color specification.
    ///
    /// # Examples
    ///
    /// ```rust
    /// let spec = loaders::ColorSpec::new();
    /// assert_eq!(spec.fg, None);
    /// ```
    pub fn new() -> Self {
        Self::default()
    }

    /// Sets the foreground color.
    ///
    /// # Examples
    ///
    /// ```rust
    /// let spec = loaders::ColorSpec::new().set_fg(loaders::Color::Cyan);
    /// assert_eq!(spec.fg, Some(loaders::Color::Cyan));
    /// ```
    pub fn set_fg(mut self, color: Color) -> Self {
        self.fg = Some(color);
        self
    }

    /// Sets the background color.
    ///
    /// # Examples
    ///
    /// ```rust
    /// let spec = loaders::ColorSpec::new().set_bg(loaders::Color::Black);
    /// assert_eq!(spec.bg, Some(loaders::Color::Black));
    /// ```
    pub fn set_bg(mut self, color: Color) -> Self {
        self.bg = Some(color);
        self
    }

    /// Enables or disables bold text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_bold(true).bold);
    /// ```
    pub fn set_bold(mut self, val: bool) -> Self {
        self.bold = val;
        self
    }

    /// Enables or disables dim text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_dim(true).dim);
    /// ```
    pub fn set_dim(mut self, val: bool) -> Self {
        self.dim = val;
        self
    }

    /// Enables or disables italic text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_italic(true).italic);
    /// ```
    pub fn set_italic(mut self, val: bool) -> Self {
        self.italic = val;
        self
    }

    /// Enables or disables underline text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_underline(true).underline);
    /// ```
    pub fn set_underline(mut self, val: bool) -> Self {
        self.underline = val;
        self
    }

    /// Enables or disables blinking text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_blink(true).blink);
    /// ```
    pub fn set_blink(mut self, val: bool) -> Self {
        self.blink = val;
        self
    }

    /// Enables or disables reverse video text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_reverse(true).reverse);
    /// ```
    pub fn set_reverse(mut self, val: bool) -> Self {
        self.reverse = val;
        self
    }

    /// Enables or disables strikethrough text.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert!(loaders::ColorSpec::new().set_strikethrough(true).strikethrough);
    /// ```
    pub fn set_strikethrough(mut self, val: bool) -> Self {
        self.strikethrough = val;
        self
    }

    /// Applies this style to text.
    ///
    /// If ANSI output is disabled, the original text is returned unchanged.
    ///
    /// # Examples
    ///
    /// ```rust
    /// let rendered = loaders::ColorSpec::new().set_bold(true).render("hi");
    /// assert!(rendered == "hi" || rendered.contains("hi"));
    /// ```
    pub fn render(&self, text: &str) -> String {
        if !ansi_enabled() {
            return text.to_string();
        }

        let mut out = String::new();
        if self.bold {
            out.push_str("\x1b[1m");
        }
        if self.dim {
            out.push_str("\x1b[2m");
        }
        if self.italic {
            out.push_str("\x1b[3m");
        }
        if self.underline {
            out.push_str("\x1b[4m");
        }
        if self.blink {
            out.push_str("\x1b[5m");
        }
        if self.reverse {
            out.push_str("\x1b[7m");
        }
        if self.strikethrough {
            out.push_str("\x1b[9m");
        }
        if let Some(fg) = &self.fg {
            out.push_str(&fg.render_fg());
        }
        if let Some(bg) = &self.bg {
            out.push_str(&bg.render_bg());
        }
        out.push_str(text);
        out.push_str(Self::reset_code());
        out
    }

    /// Returns the ANSI reset sequence.
    ///
    /// # Examples
    ///
    /// ```rust
    /// assert_eq!(loaders::ColorSpec::reset_code(), "\x1b[0m");
    /// ```
    pub fn reset_code() -> &'static str {
        "\x1b[0m"
    }
}

/// Returns whether ANSI output should be emitted.
///
/// The `NO_COLOR` environment variable disables ANSI output. CI environments
/// without explicit color support are treated as colorless.
///
/// # Examples
///
/// ```rust
/// let _ = loaders::style::color::ansi_enabled();
/// ```
pub fn ansi_enabled() -> bool {
    std::env::var_os("NO_COLOR").is_none() && color_support() != ColorSupport::None
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::env;
    use std::sync::Mutex;

    static ENV_LOCK: Mutex<()> = Mutex::new(());

    fn with_env_lock(f: impl FnOnce()) {
        match ENV_LOCK.lock() {
            Ok(_guard) => f(),
            Err(poisoned) => {
                let _guard = poisoned.into_inner();
                f();
            }
        }
    }

    #[test]
    fn test_color16_fg_code() {
        assert_eq!(Color::Red.render_fg(), "\x1b[31m");
    }

    #[test]
    fn test_color16_bg_code() {
        assert_eq!(Color::Blue.render_bg(), "\x1b[44m");
    }

    #[test]
    fn test_color256_fg_code() {
        assert_eq!(Color::Color256(42).render_fg(), "\x1b[38;5;42m");
    }

    #[test]
    fn test_rgb_fg_code() {
        assert_eq!(Color::Rgb(1, 2, 3).render_fg(), "\x1b[38;2;1;2;3m");
    }

    #[test]
    fn test_colorspec_bold() {
        let rendered = ColorSpec::new().set_bold(true).render("x");
        assert!(rendered == "x" || rendered.contains("\x1b[1m"));
    }

    #[test]
    fn test_colorspec_combined() {
        let spec = ColorSpec::new()
            .set_bold(true)
            .set_fg(Color::Cyan)
            .set_bg(Color::Black);
        let rendered = spec.render("x");
        assert!(rendered == "x" || rendered.contains("\x1b[36m"));
    }

    #[test]
    fn test_no_color_env_suppresses_ansi() {
        with_env_lock(|| {
            unsafe {
                env::set_var("NO_COLOR", "1");
            }
            assert_eq!(ColorSpec::new().set_bold(true).render("x"), "x");
            unsafe {
                env::remove_var("NO_COLOR");
            }
        });
    }

    #[test]
    fn test_render_wraps_text() {
        let rendered = ColorSpec::new().set_fg(Color::Green).render("ok");
        assert!(rendered == "ok" || rendered.ends_with("\x1b[0m"));
    }

    #[test]
    fn test_reset_code_value() {
        assert_eq!(ColorSpec::reset_code(), "\x1b[0m");
    }
}