yansi-term 0.1.2

use std::fmt::{self, Display, Write};

use crate::{Colour, Style};

impl Style {
    /// Write any bytes that go *before* a piece of text to the given writer.
    pub fn write_prefix(&self, f: &mut fmt::Formatter) -> Result<bool, fmt::Error> {
        let mut written_anything = false;
        macro_rules! write_anything {
            () => {
                if written_anything {
                    f.write_char(';')?;
                } else {
                    // Write the codes’ prefix, then write numbers, separated by
                    // semicolons, for each text style we want to apply.
                    f.write_str("\x1B[")?;
                    written_anything = true;
                }
            };
        }
        macro_rules! write_char {
            ($cond:ident, $c:expr) => {
                if self.$cond {
                    write_anything!();
                    f.write_char($c)?;
                }
            };
        }
        macro_rules! write_chars {
            ($cond:ident => $c:expr) => { write_char!($cond, $c); };
            ($cond:ident => $c:expr, $($t:tt)+) => {
                write_char!($cond, $c);
                write_chars!($($t)+);
            };
        }

        write_chars!(
            is_bold => '1',
            is_dimmed => '2',
            is_italic => '3',
            is_underline => '4',
            is_blink => '5',
            is_reverse => '7',
            is_hidden => '8',
            is_strikethrough => '9'
        );

        // The foreground and background colours, if specified, need to be
        // handled specially because the number codes are more complicated.
        // (see `write_background_code` and `write_foreground_code`)
        if let Some(bg) = self.background {
            write_anything!();
            bg.write_background_code(f)?;
        }

        if let Some(fg) = self.foreground {
            write_anything!();
            fg.write_foreground_code(f)?;
        }

        if written_anything {
            // All the codes end with an `m`, because reasons.
            f.write_char('m')?;
        }

        Ok(written_anything)
    }

    /// Write any bytes that go *after* a piece of text to the given writer.
    #[inline]
    pub fn write_reset(f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(RESET)
    }
}

impl Colour {
    /// Write any bytes that go *before* a piece of text to the given writer.
    #[inline]
    pub fn write_prefix(self, f: &mut fmt::Formatter) -> Result<bool, fmt::Error> {
        self.normal().write_prefix(f)
    }
}

/// The code to send to reset all styles and return to `Style::default()`.
pub static RESET: &str = "\x1B[0m";

macro_rules! write_color {
    ($_self:ident, $f:ident =>
        $black:expr, $red:expr, $green:expr, $yellow:expr, $blue:expr,
        $purple:expr, $cyan:expr, $white:expr, $fixed:expr, $rgb:expr) => {{
        use Colour::*;
        match $_self {
            Black => $f.write_str($black),
            Red => $f.write_str($red),
            Green => $f.write_str($green),
            Yellow => $f.write_str($yellow),
            Blue => $f.write_str($blue),
            Purple => $f.write_str($purple),
            Cyan => $f.write_str($cyan),
            White => $f.write_str($white),
            Fixed(num) => {
                $f.write_str($fixed)?;
                num.fmt($f)
            }
            RGB(r, g, b) => {
                $f.write_str($rgb)?;
                r.fmt($f)?;
                $f.write_char(';')?;
                g.fmt($f)?;
                $f.write_char(';')?;
                b.fmt($f)
            }
        }
    }};
}

impl Colour {
    #[inline]
    fn write_foreground_code(self, f: &mut fmt::Formatter) -> fmt::Result {
        write_color!(self, f => "30", "31", "32", "33", "34", "35", "36", "37", "38;5;", "38;2;")
    }

    #[inline]
    fn write_background_code(self, f: &mut fmt::Formatter) -> fmt::Result {
        write_color!(self, f => "40", "41", "42", "43", "44", "45", "46", "47", "48;5;", "48;2;")
    }
}

#[cfg(test)]
mod test {
    use crate::{Colour::*, Style};

    macro_rules! test {
        ($name: ident: $style: expr; $input: expr => $result: expr) => {
            #[test]
            fn $name() {
                assert_eq!($style.paint($input).to_string(), $result.to_string());
            }
        };
    }

    test!(plain:                 Style::default();                  "text/plain" => "text/plain");
    test!(red:                   Red;                               "hi" => "\x1B[31mhi\x1B[0m");
    test!(black:                 Black.normal();                    "hi" => "\x1B[30mhi\x1B[0m");
    test!(yellow_bold:           Yellow.bold();                     "hi" => "\x1B[1;33mhi\x1B[0m");
    test!(yellow_bold_2:         Yellow.normal().bold();            "hi" => "\x1B[1;33mhi\x1B[0m");
    test!(blue_underline:        Blue.underline();                  "hi" => "\x1B[4;34mhi\x1B[0m");
    test!(green_bold_ul:         Green.bold().underline();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
    test!(green_bold_ul_2:       Green.underline().bold();          "hi" => "\x1B[1;4;32mhi\x1B[0m");
    test!(purple_on_white:       Purple.on(White);                  "hi" => "\x1B[47;35mhi\x1B[0m");
    test!(purple_on_white_2:     Purple.normal().on(White);         "hi" => "\x1B[47;35mhi\x1B[0m");
    test!(yellow_on_blue:        Style::new().on(Blue).fg(Yellow);  "hi" => "\x1B[44;33mhi\x1B[0m");
    test!(yellow_on_blue_2:      Cyan.on(Blue).fg(Yellow);          "hi" => "\x1B[44;33mhi\x1B[0m");
    test!(cyan_bold_on_white:    Cyan.bold().on(White);             "hi" => "\x1B[1;47;36mhi\x1B[0m");
    test!(cyan_ul_on_white:      Cyan.underline().on(White);        "hi" => "\x1B[4;47;36mhi\x1B[0m");
    test!(cyan_bold_ul_on_white: Cyan.bold().underline().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
    test!(cyan_ul_bold_on_white: Cyan.underline().bold().on(White); "hi" => "\x1B[1;4;47;36mhi\x1B[0m");
    test!(fixed:                 Fixed(100);                        "hi" => "\x1B[38;5;100mhi\x1B[0m");
    test!(fixed_on_purple:       Fixed(100).on(Purple);             "hi" => "\x1B[45;38;5;100mhi\x1B[0m");
    test!(fixed_on_fixed:        Fixed(100).on(Fixed(200));         "hi" => "\x1B[48;5;200;38;5;100mhi\x1B[0m");
    test!(rgb:                   RGB(70,130,180);                   "hi" => "\x1B[38;2;70;130;180mhi\x1B[0m");
    test!(rgb_on_blue:           RGB(70,130,180).on(Blue);          "hi" => "\x1B[44;38;2;70;130;180mhi\x1B[0m");
    test!(blue_on_rgb:           Blue.on(RGB(70,130,180));          "hi" => "\x1B[48;2;70;130;180;34mhi\x1B[0m");
    test!(rgb_on_rgb:            RGB(70,130,180).on(RGB(5,10,15));  "hi" => "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
    test!(bold:                  Style::new().bold();               "hi" => "\x1B[1mhi\x1B[0m");
    test!(underline:             Style::new().underline();          "hi" => "\x1B[4mhi\x1B[0m");
    test!(bunderline:            Style::new().bold().underline();   "hi" => "\x1B[1;4mhi\x1B[0m");
    test!(dimmed:                Style::new().dimmed();             "hi" => "\x1B[2mhi\x1B[0m");
    test!(italic:                Style::new().italic();             "hi" => "\x1B[3mhi\x1B[0m");
    test!(blink:                 Style::new().blink();              "hi" => "\x1B[5mhi\x1B[0m");
    test!(reverse:               Style::new().reverse();            "hi" => "\x1B[7mhi\x1B[0m");
    test!(hidden:                Style::new().hidden();             "hi" => "\x1B[8mhi\x1B[0m");
    test!(stricken:              Style::new().strikethrough();      "hi" => "\x1B[9mhi\x1B[0m");

    macro_rules! test_fn {
        ($name:ident: $style:expr; $result:expr) => {
            #[test]
            fn $name() {
                let string = String::from("hi");
                let string: &str = &string;
                assert_eq!(
                    $style.paint_fn(|f| f.write_str(string)).to_string(),
                    $result.to_string()
                );
            }
        };
    }

    test_fn!(plain_fn:                 Style::default();                  "hi");
    test_fn!(red_fn:                   Red;                               "\x1B[31mhi\x1B[0m");
    test_fn!(black_fn:                 Black.normal();                    "\x1B[30mhi\x1B[0m");
    test_fn!(yellow_bold_fn:           Yellow.bold();                     "\x1B[1;33mhi\x1B[0m");
    test_fn!(yellow_bold_2_fn:         Yellow.normal().bold();            "\x1B[1;33mhi\x1B[0m");
    test_fn!(blue_underline_fn:        Blue.underline();                  "\x1B[4;34mhi\x1B[0m");
    test_fn!(green_bold_ul_fn:         Green.bold().underline();          "\x1B[1;4;32mhi\x1B[0m");
    test_fn!(green_bold_ul_2_fn:       Green.underline().bold();          "\x1B[1;4;32mhi\x1B[0m");
    test_fn!(purple_on_white_fn:       Purple.on(White);                  "\x1B[47;35mhi\x1B[0m");
    test_fn!(purple_on_white_2_fn:     Purple.normal().on(White);         "\x1B[47;35mhi\x1B[0m");
    test_fn!(yellow_on_blue_fn:        Style::new().on(Blue).fg(Yellow);  "\x1B[44;33mhi\x1B[0m");
    test_fn!(yellow_on_blue_2_fn:      Cyan.on(Blue).fg(Yellow);          "\x1B[44;33mhi\x1B[0m");
    test_fn!(cyan_bold_on_white_fn:    Cyan.bold().on(White);             "\x1B[1;47;36mhi\x1B[0m");
    test_fn!(cyan_ul_on_white_fn:      Cyan.underline().on(White);        "\x1B[4;47;36mhi\x1B[0m");
    test_fn!(cyan_bold_ul_on_white_fn: Cyan.bold().underline().on(White); "\x1B[1;4;47;36mhi\x1B[0m");
    test_fn!(cyan_ul_bold_on_white_fn: Cyan.underline().bold().on(White); "\x1B[1;4;47;36mhi\x1B[0m");
    test_fn!(fixed_fn:                 Fixed(100);                        "\x1B[38;5;100mhi\x1B[0m");
    test_fn!(fixed_on_purple_fn:       Fixed(100).on(Purple);             "\x1B[45;38;5;100mhi\x1B[0m");
    test_fn!(fixed_on_fixed_fn:        Fixed(100).on(Fixed(200));         "\x1B[48;5;200;38;5;100mhi\x1B[0m");
    test_fn!(rgb_fn:                   RGB(70,130,180);                   "\x1B[38;2;70;130;180mhi\x1B[0m");
    test_fn!(rgb_on_blue_fn:           RGB(70,130,180).on(Blue);          "\x1B[44;38;2;70;130;180mhi\x1B[0m");
    test_fn!(blue_on_rgb_fn:           Blue.on(RGB(70,130,180));          "\x1B[48;2;70;130;180;34mhi\x1B[0m");
    test_fn!(rgb_on_rgb_fn:            RGB(70,130,180).on(RGB(5,10,15));  "\x1B[48;2;5;10;15;38;2;70;130;180mhi\x1B[0m");
    test_fn!(bold_fn:                  Style::new().bold();               "\x1B[1mhi\x1B[0m");
    test_fn!(underline_fn:             Style::new().underline();          "\x1B[4mhi\x1B[0m");
    test_fn!(bunderline_fn:            Style::new().bold().underline();   "\x1B[1;4mhi\x1B[0m");
    test_fn!(dimmed_fn:                Style::new().dimmed();             "\x1B[2mhi\x1B[0m");
    test_fn!(italic_fn:                Style::new().italic();             "\x1B[3mhi\x1B[0m");
    test_fn!(blink_fn:                 Style::new().blink();              "\x1B[5mhi\x1B[0m");
    test_fn!(reverse_fn:               Style::new().reverse();            "\x1B[7mhi\x1B[0m");
    test_fn!(hidden_fn:                Style::new().hidden();             "\x1B[8mhi\x1B[0m");
    test_fn!(stricken_fn:              Style::new().strikethrough();      "\x1B[9mhi\x1B[0m");

    #[test]
    fn test_move() {
        let string = String::from("hi");
        assert_eq!(
            Style::default()
                .paint_fn(|f| f.write_str(&string))
                .to_string(),
            "hi"
        );
    }

    #[test]
    fn test_ref() {
        let string = &String::from("hi");
        assert_eq!(
            Style::default()
                .paint_fn(|f| f.write_str(string))
                .to_string(),
            "hi"
        );
    }

    #[test]
    fn test_debug() {
        let a = vec![1, 2, 3];
        assert_eq!(
            Style::default()
                .paint_fn(|f| std::fmt::Debug::fmt(&a, f))
                .to_string(),
            "[1, 2, 3]"
        );
        assert_eq!(
            Style::default()
                .bold()
                .paint_fn(|f| std::fmt::Debug::fmt(&a, f))
                .to_string(),
            "\x1B[1m[1, 2, 3]\x1B[0m"
        );
    }

    #[test]
    fn test_write() {
        assert_eq!(
            Style::default()
                .paint_fn(|f| write!(f, "{:.5}", 1.0))
                .to_string(),
            "1.00000"
        );
        assert_eq!(
            Style::default()
                .bold()
                .paint_fn(|f| write!(f, "{:.5}", 1.0))
                .to_string(),
            "\x1B[1m1.00000\x1B[0m"
        );
    }

    /// Can not write the same `impl Display` two or more times
    /// else return error
    #[test]
    fn test_error() {
        use std::fmt::Write;
        let a = Style::default().paint("foo");
        let _ = a.to_string();
        let mut b = String::new();

        assert!(write!(b, "{}", a).is_err());
    }
}