From 78319556201014b7c6d1c382274a41b6394eb379 Mon Sep 17 00:00:00 2001 From: Mattias Eriksson Date: Wed, 20 Mar 2019 08:04:54 +0100 Subject: [PATCH 1/6] Add support for Light colors and Bright modifier --- aurora.go | 123 +++++++++++++++++++++++---------- color.go | 16 ++++- value.go | 200 +++++++++++++++++++++++++++++++++++++++++++----------- wrap.go | 161 +++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 419 insertions(+), 81 deletions(-) diff --git a/aurora.go b/aurora.go index d4c9718..5ad98b3 100644 --- a/aurora.go +++ b/aurora.go @@ -40,7 +40,15 @@ type Aurora interface { Blue(arg interface{}) Value Magenta(arg interface{}) Value Cyan(arg interface{}) Value + LightGray(arg interface{}) Value Gray(arg interface{}) Value + LightRed(arg interface{}) Value + LightGreen(arg interface{}) Value + Yellow(arg interface{}) Value + LightBlue(arg interface{}) Value + LightMagenta(arg interface{}) Value + LightCyan(arg interface{}) Value + White(arg interface{}) Value BgBlack(arg interface{}) Value BgRed(arg interface{}) Value BgGreen(arg interface{}) Value @@ -48,9 +56,18 @@ type Aurora interface { BgBlue(arg interface{}) Value BgMagenta(arg interface{}) Value BgCyan(arg interface{}) Value + BgLightGray(arg interface{}) Value BgGray(arg interface{}) Value + BgLightRed(arg interface{}) Value + BgLightGreen(arg interface{}) Value + BgYellow(arg interface{}) Value + BgLightBlue(arg interface{}) Value + BgLightMagenta(arg interface{}) Value + BgLightCyan(arg interface{}) Value + BgWhite(arg interface{}) Value Bold(arg interface{}) Value Inverse(arg interface{}) Value + Bright(arg interface{}) Value Colorize(arg interface{}, color Color) Value Sprintf(format interface{}, args ...interface{}) string } @@ -69,24 +86,41 @@ func NewAurora(enableColors bool) Aurora { type auroraClear struct{} -func (auroraClear) Black(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Red(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Green(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Brown(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Blue(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Magenta(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Cyan(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Gray(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgBlack(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgRed(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgGreen(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgBrown(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgBlue(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgMagenta(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgCyan(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) BgGray(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Bold(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Inverse(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Black(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Red(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Green(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Brown(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Blue(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Magenta(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Cyan(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) LightGray(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Gray(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) LightRed(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) LightGreen(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Yellow(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) LightBlue(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) LightMagenta(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) LightCyan(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) White(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgBlack(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgRed(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgGreen(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgBrown(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgBlue(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgMagenta(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgCyan(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgLightGray(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgGray(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgLightRed(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgLightGreen(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgYellow(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgLightBlue(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgLightMagenta(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgLightCyan(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) BgWhite(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Bold(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Inverse(arg interface{}) Value { return valueClear{arg} } +func (auroraClear) Bright(arg interface{}) Value { return valueClear{arg} } func (auroraClear) Colorize(arg interface{}, color Color) Value { return valueClear{arg} @@ -103,24 +137,41 @@ func (auroraClear) Sprintf(format interface{}, args ...interface{}) string { type aurora struct{} -func (aurora) Black(arg interface{}) Value { return Black(arg) } -func (aurora) Red(arg interface{}) Value { return Red(arg) } -func (aurora) Green(arg interface{}) Value { return Green(arg) } -func (aurora) Brown(arg interface{}) Value { return Brown(arg) } -func (aurora) Blue(arg interface{}) Value { return Blue(arg) } -func (aurora) Magenta(arg interface{}) Value { return Magenta(arg) } -func (aurora) Cyan(arg interface{}) Value { return Cyan(arg) } -func (aurora) Gray(arg interface{}) Value { return Gray(arg) } -func (aurora) BgBlack(arg interface{}) Value { return BgBlack(arg) } -func (aurora) BgRed(arg interface{}) Value { return BgRed(arg) } -func (aurora) BgGreen(arg interface{}) Value { return BgGreen(arg) } -func (aurora) BgBrown(arg interface{}) Value { return BgBrown(arg) } -func (aurora) BgBlue(arg interface{}) Value { return BgBlue(arg) } -func (aurora) BgMagenta(arg interface{}) Value { return BgMagenta(arg) } -func (aurora) BgCyan(arg interface{}) Value { return BgCyan(arg) } -func (aurora) BgGray(arg interface{}) Value { return BgGray(arg) } -func (aurora) Bold(arg interface{}) Value { return Bold(arg) } -func (aurora) Inverse(arg interface{}) Value { return Inverse(arg) } +func (aurora) Black(arg interface{}) Value { return Black(arg) } +func (aurora) Red(arg interface{}) Value { return Red(arg) } +func (aurora) Green(arg interface{}) Value { return Green(arg) } +func (aurora) Brown(arg interface{}) Value { return Brown(arg) } +func (aurora) Blue(arg interface{}) Value { return Blue(arg) } +func (aurora) Magenta(arg interface{}) Value { return Magenta(arg) } +func (aurora) Cyan(arg interface{}) Value { return Cyan(arg) } +func (aurora) LightGray(arg interface{}) Value { return LightGray(arg) } +func (aurora) Gray(arg interface{}) Value { return Gray(arg) } +func (aurora) LightRed(arg interface{}) Value { return LightRed(arg) } +func (aurora) LightGreen(arg interface{}) Value { return LightGreen(arg) } +func (aurora) Yellow(arg interface{}) Value { return Yellow(arg) } +func (aurora) LightBlue(arg interface{}) Value { return LightBlue(arg) } +func (aurora) LightMagenta(arg interface{}) Value { return LightMagenta(arg) } +func (aurora) LightCyan(arg interface{}) Value { return LightCyan(arg) } +func (aurora) White(arg interface{}) Value { return White(arg) } +func (aurora) BgBlack(arg interface{}) Value { return BgBlack(arg) } +func (aurora) BgRed(arg interface{}) Value { return BgRed(arg) } +func (aurora) BgGreen(arg interface{}) Value { return BgGreen(arg) } +func (aurora) BgBrown(arg interface{}) Value { return BgBrown(arg) } +func (aurora) BgBlue(arg interface{}) Value { return BgBlue(arg) } +func (aurora) BgMagenta(arg interface{}) Value { return BgMagenta(arg) } +func (aurora) BgCyan(arg interface{}) Value { return BgCyan(arg) } +func (aurora) BgLightGray(arg interface{}) Value { return BgLightGray(arg) } +func (aurora) BgGray(arg interface{}) Value { return BgGray(arg) } +func (aurora) BgLightRed(arg interface{}) Value { return BgLightRed(arg) } +func (aurora) BgLightGreen(arg interface{}) Value { return BgLightGreen(arg) } +func (aurora) BgYellow(arg interface{}) Value { return BgYellow(arg) } +func (aurora) BgLightBlue(arg interface{}) Value { return BgLightBlue(arg) } +func (aurora) BgLightMagenta(arg interface{}) Value { return BgLightMagenta(arg) } +func (aurora) BgLightCyan(arg interface{}) Value { return BgLightCyan(arg) } +func (aurora) BgWhite(arg interface{}) Value { return BgWhite(arg) } +func (aurora) Bold(arg interface{}) Value { return Bold(arg) } +func (aurora) Inverse(arg interface{}) Value { return Inverse(arg) } +func (aurora) Bright(arg interface{}) Value { return Bright(arg) } func (aurora) Colorize(arg interface{}, color Color) Value { return Colorize(arg, color) diff --git a/color.go b/color.go index b22ffa4..898f960 100644 --- a/color.go +++ b/color.go @@ -34,6 +34,7 @@ type Color int const ( BoldFm Color = 1 << iota // bold InverseFm // inverse + BrightFm // bright ) // foreground @@ -68,7 +69,7 @@ const ( // IsValid returns true if a color looks like valid func (c Color) IsValid() bool { - return c&(BoldFm|InverseFm|maskFg|maskBg) != 0 || c == 0 + return c&(BrightFm|BoldFm|InverseFm|maskFg|maskBg) != 0 || c == 0 } const ( @@ -106,13 +107,22 @@ func (c Color) appendNos(bs []byte) []byte { } else { semicolon = true } - bs = append(bs, '3', '0'+byte((c>>8)&0xff)-1) + if c&BrightFm != 0 { + bs = append(bs, '9', '0'+byte((c>>8)&0xff)-1) + } else { + bs = append(bs, '3', '0'+byte((c>>8)&0xff)-1) + } } if c&maskBg != 0 { if semicolon { bs = append(bs, ';') } - bs = append(bs, '4', '0'+byte((c>>16)&0xff)-1) + if c&BrightFm != 0 { + bs = append(bs, '1', '0', '0'+byte((c>>16)&0xff)-1) + } else { + bs = append(bs, '4', '0'+byte((c>>16)&0xff)-1) + + } } return bs } diff --git a/value.go b/value.go index b0f4bb1..1b8a447 100644 --- a/value.go +++ b/value.go @@ -49,24 +49,41 @@ type Value interface { tail() Color setTail(Color) Value - Black() Value // change foreground color to black - Red() Value // change foreground color to red - Green() Value // change foreground color to green - Brown() Value // change foreground color to brown - Blue() Value // change foreground color to blue - Magenta() Value // change foreground color to magenta - Cyan() Value // change foreground color to cyan - Gray() Value // change foreground color to gray - BgBlack() Value // change background color to black - BgRed() Value // change background color to red - BgGreen() Value // change background color to green - BgBrown() Value // change background color to brown - BgBlue() Value // change background color to blue - BgMagenta() Value // change background color to magenta - BgCyan() Value // change background color to cyan - BgGray() Value // change background color to gray - Bold() Value // change format to bold - Inverse() Value // change format to inversed + Black() Value // change foreground color to black + Red() Value // change foreground color to red + Green() Value // change foreground color to green + Brown() Value // change foreground color to brown + Blue() Value // change foreground color to blue + Magenta() Value // change foreground color to magenta + Cyan() Value // change foreground color to cyan + LightGray() Value // change foreground color to light gray + Gray() Value // change foreground color to gray + LightRed() Value // change foreground color to light red + LightGreen() Value // change foreground color to light green + Yellow() Value // change foreground color to yellow + LightBlue() Value // change foreground color to light blue + LightMagenta() Value // change foreground color to light magenta + LightCyan() Value // change foreground color to light cyan + White() Value // change foreground color to white + BgBlack() Value // change background color to black + BgRed() Value // change background color to red + BgGreen() Value // change background color to green + BgBrown() Value // change background color to brown + BgBlue() Value // change background color to blue + BgMagenta() Value // change background color to magenta + BgCyan() Value // change background color to cyan + BgLightGray() Value // change background color to light gray + BgGray() Value // change background color to gray + BgLightRed() Value // change background color to light red + BgLightGreen() Value // change background color to light green + BgYellow() Value // change background color to yellow + BgLightBlue() Value // change background color to light blue + BgLightMagenta() Value // change background color to light magenta + BgLightCyan() Value // change background color to light cyan + BgWhite() Value // change background color to white + Bold() Value // change format to bold + Inverse() Value // change format to inversed + Bright() Value // change format to bright } // Value without colors @@ -82,24 +99,41 @@ func (v valueClear) Value() interface{} { return v.value } func (v valueClear) tail() Color { return 0 } func (v valueClear) setTail(Color) Value { return v } -func (v valueClear) Black() Value { return v } -func (v valueClear) Red() Value { return v } -func (v valueClear) Green() Value { return v } -func (v valueClear) Brown() Value { return v } -func (v valueClear) Blue() Value { return v } -func (v valueClear) Magenta() Value { return v } -func (v valueClear) Cyan() Value { return v } -func (v valueClear) Gray() Value { return v } -func (v valueClear) BgBlack() Value { return v } -func (v valueClear) BgRed() Value { return v } -func (v valueClear) BgGreen() Value { return v } -func (v valueClear) BgBrown() Value { return v } -func (v valueClear) BgBlue() Value { return v } -func (v valueClear) BgMagenta() Value { return v } -func (v valueClear) BgCyan() Value { return v } -func (v valueClear) BgGray() Value { return v } -func (v valueClear) Bold() Value { return v } -func (v valueClear) Inverse() Value { return v } +func (v valueClear) Black() Value { return v } +func (v valueClear) Red() Value { return v } +func (v valueClear) Green() Value { return v } +func (v valueClear) Brown() Value { return v } +func (v valueClear) Blue() Value { return v } +func (v valueClear) Magenta() Value { return v } +func (v valueClear) Cyan() Value { return v } +func (v valueClear) LightGray() Value { return v } +func (v valueClear) Gray() Value { return v } +func (v valueClear) LightRed() Value { return v } +func (v valueClear) LightGreen() Value { return v } +func (v valueClear) Yellow() Value { return v } +func (v valueClear) LightBlue() Value { return v } +func (v valueClear) LightMagenta() Value { return v } +func (v valueClear) LightCyan() Value { return v } +func (v valueClear) White() Value { return v } +func (v valueClear) BgBlack() Value { return v } +func (v valueClear) BgRed() Value { return v } +func (v valueClear) BgGreen() Value { return v } +func (v valueClear) BgBrown() Value { return v } +func (v valueClear) BgBlue() Value { return v } +func (v valueClear) BgMagenta() Value { return v } +func (v valueClear) BgCyan() Value { return v } +func (v valueClear) BgLightGray() Value { return v } +func (v valueClear) BgGray() Value { return v } +func (v valueClear) BgLightRed() Value { return v } +func (v valueClear) BgLightGreen() Value { return v } +func (v valueClear) BgYellow() Value { return v } +func (v valueClear) BgLightBlue() Value { return v } +func (v valueClear) BgLightMagenta() Value { return v } +func (v valueClear) BgLightCyan() Value { return v } +func (v valueClear) BgWhite() Value { return v } +func (v valueClear) Bold() Value { return v } +func (v valueClear) Inverse() Value { return v } +func (v valueClear) Bright() Value { return v } func (v valueClear) Format(s fmt.State, verb rune) { // it's enough for many cases (%-+020.10f) @@ -238,6 +272,7 @@ func (v value) Green() Value { return v } +//This is really dark yellow func (v value) Brown() Value { v.color = (v.color & (^maskFg)) | BrownFg return v @@ -258,11 +293,53 @@ func (v value) Cyan() Value { return v } -func (v value) Gray() Value { +//This is really dark white +func (v value) LightGray() Value { v.color = (v.color & (^maskFg)) | GrayFg return v } +//This is really bright black +func (v value) Gray() Value { + v.color = (v.color & (^maskFg)) | BlackFg | BrightFm + return v +} + +func (v value) LightRed() Value { + v.color = (v.color & (^maskFg)) | RedFg | BrightFm + return v +} + +func (v value) LightGreen() Value { + v.color = (v.color & (^maskFg)) | GreenFg | BrightFm + return v +} + +func (v value) Yellow() Value { + v.color = (v.color & (^maskFg)) | BrownFg | BrightFm + return v +} + +func (v value) LightBlue() Value { + v.color = (v.color & (^maskFg)) | BlueFg | BrightFm + return v +} + +func (v value) LightMagenta() Value { + v.color = (v.color & (^maskFg)) | MagentaFg | BrightFm + return v +} + +func (v value) LightCyan() Value { + v.color = (v.color & (^maskFg)) | CyanFg | BrightFm + return v +} + +func (v value) White() Value { + v.color = (v.color & (^maskFg)) | GrayFg | BrightFm + return v +} + func (v value) BgBlack() Value { v.color = (v.color & (^maskBg)) | BlackBg return v @@ -298,11 +375,53 @@ func (v value) BgCyan() Value { return v } -func (v value) BgGray() Value { +//This is really dark white +func (v value) BgLightGray() Value { v.color = (v.color & (^maskBg)) | GrayBg return v } +//This is really light black +func (v value) BgGray() Value { + v.color = (v.color & (^maskBg)) | BlackBg | BrightFm + return v +} + +func (v value) BgLightRed() Value { + v.color = (v.color & (^maskBg)) | RedBg | BrightFm + return v +} + +func (v value) BgLightGreen() Value { + v.color = (v.color & (^maskBg)) | GreenBg | BrightFm + return v +} + +func (v value) BgYellow() Value { + v.color = (v.color & (^maskBg)) | BrownBg | BrightFm + return v +} + +func (v value) BgLightBlue() Value { + v.color = (v.color & (^maskBg)) | BlueBg | BrightFm + return v +} + +func (v value) BgLightMagenta() Value { + v.color = (v.color & (^maskBg)) | MagentaBg | BrightFm + return v +} + +func (v value) BgLightCyan() Value { + v.color = (v.color & (^maskBg)) | CyanBg | BrightFm + return v +} + +func (v value) BgWhite() Value { + v.color = (v.color & (^maskBg)) | GrayBg | BrightFm + return v +} + func (v value) Bold() Value { v.color |= BoldFm return v @@ -312,3 +431,8 @@ func (v value) Inverse() Value { v.color |= InverseFm return v } + +func (v value) Bright() Value { + v.color |= BrightFm + return v +} diff --git a/wrap.go b/wrap.go index 5c05aee..3a0b538 100644 --- a/wrap.go +++ b/wrap.go @@ -113,8 +113,8 @@ func Cyan(arg interface{}) Value { return value{arg, CyanFg, 0} } -// Gray converts argument into formated/colorized value -func Gray(arg interface{}) Value { +// LightGray converts argument into formated/colorized value +func LightGray(arg interface{}) Value { if val, ok := arg.(value); ok { val.color = (val.color & (^maskFg)) | GrayFg return val @@ -122,6 +122,78 @@ func Gray(arg interface{}) Value { return value{arg, GrayFg, 0} } +// Gray converts argument into formated/colorized value +func Gray(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | BlackFg | BrightFm + return val + } + return value{arg, BlackFg | BrightFm, 0} +} + +// LightRed converts argument into formated/colorized value +func LightRed(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | RedFg | BrightFm + return val + } + return value{arg, RedFg | BrightFm, 0} +} + +// LightGreen converts argument into formated/colorized value +func LightGreen(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | GreenFg | BrightFm + return val + } + return value{arg, GreenFg | BrightFm, 0} +} + +// Yellow converts argument into formated/colorized value +func Yellow(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | BrownFg | BrightFm + return val + } + return value{arg, BrownFg | BrightFm, 0} +} + +// LightBlue converts argument into formated/colorized value +func LightBlue(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | BlueFg | BrightFm + return val + } + return value{arg, BlueFg | BrightFm, 0} +} + +// LightMagenta converts argument into formated/colorized value +func LightMagenta(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | MagentaFg | BrightFm + return val + } + return value{arg, MagentaFg | BrightFm, 0} +} + +// LightCyan converts argument into formated/colorized value +func LightCyan(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | CyanFg | BrightFm + return val + } + return value{arg, CyanFg | BrightFm, 0} +} + +// White converts argument into formated/colorized value +func White(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskFg)) | GrayFg | BrightFm + return val + } + return value{arg, GrayFg | BrightFm, 0} +} + // // Background colors // @@ -189,8 +261,8 @@ func BgCyan(arg interface{}) Value { return value{arg, CyanBg, 0} } -// BgGray converts argument into formated/colorized value -func BgGray(arg interface{}) Value { +// BgLightGray converts argument into formated/colorized value +func BgLightGray(arg interface{}) Value { if val, ok := arg.(value); ok { val.color = (val.color & (^maskBg)) | GrayBg return val @@ -198,6 +270,87 @@ func BgGray(arg interface{}) Value { return value{arg, GrayBg, 0} } +// BgGray converts argument into formated/colorized value +func BgGray(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | BlackBg | BrightFm + return val + } + return value{arg, BlackBg | BrightFm, 0} +} + +// BgLightRed converts argument into formated/colorized value +func BgLightRed(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | RedBg | BrightFm + return val + } + return value{arg, RedBg | BrightFm, 0} +} + +// BgLightGreen converts argument into formated/colorized value +func BgLightGreen(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | GreenBg | BrightFm + return val + } + return value{arg, GreenBg | BrightFm, 0} +} + +// BgYellow converts argument into formated/colorized value +func BgYellow(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | BrownBg | BrightFm + return val + } + return value{arg, BrownBg | BrightFm, 0} +} + +// BgLightBlue converts argument into formated/colorized value +func BgLightBlue(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | BlueBg | BrightFm + return val + } + return value{arg, BlueBg | BrightFm, 0} +} + +// BgLightMagenta converts argument into formated/colorized value +func BgLightMagenta(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | MagentaBg | BrightFm + return val + } + return value{arg, MagentaBg | BrightFm, 0} +} + +// BgLightCyan converts argument into formated/colorized value +func BgLightCyan(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | CyanBg | BrightFm + return val + } + return value{arg, CyanBg | BrightFm, 0} +} + +// BgWhtie converts argument into formated/colorized value +func BgWhite(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color = (val.color & (^maskBg)) | GrayBg | BrightFm + return val + } + return value{arg, GrayBg | BrightFm, 0} +} + +// Bright converts argument into formated/colorized value +func Bright(arg interface{}) Value { + if val, ok := arg.(value); ok { + val.color |= BrightFm + return val + } + return value{arg, BrightFm, 0} +} + // Bold converts argument into formated/colorized value func Bold(arg interface{}) Value { if val, ok := arg.(value); ok { From d179c80116cff4eb12803b133585e844d83057ec Mon Sep 17 00:00:00 2001 From: Mattias Eriksson Date: Wed, 20 Mar 2019 10:40:07 +0100 Subject: [PATCH 2/6] Make tests pass and add some basic tests for new colors --- aurora_test.go | 40 +++++++++++++++++++++++++++++++++++++--- value_test.go | 8 ++++---- wrap_test.go | 12 ++++++------ 3 files changed, 47 insertions(+), 13 deletions(-) diff --git a/aurora_test.go b/aurora_test.go index 77219fc..6d114c0 100644 --- a/aurora_test.go +++ b/aurora_test.go @@ -71,7 +71,15 @@ func Test_auroraClear_methods(t *testing.T) { test("Blue", a.Blue("x")) test("Magenta", a.Magenta("x")) test("Cyan", a.Cyan("x")) + test("LightGray", a.LightGray("x")) test("Gray", a.Gray("x")) + test("LightRed", a.LightRed("x")) + test("LightGreen", a.LightGreen("x")) + test("Yellow", a.Yellow("x")) + test("LightBlue", a.LightBlue("x")) + test("LightMagenta", a.LightMagenta("x")) + test("LightCyan", a.LightCyan("x")) + test("White", a.White("x")) test("BgBlack", a.BgBlack("x")) test("BgRed", a.BgRed("x")) test("BgGreen", a.BgGreen("x")) @@ -79,9 +87,18 @@ func Test_auroraClear_methods(t *testing.T) { test("BgBlue", a.BgBlue("x")) test("BgMagenta", a.BgMagenta("x")) test("BgCyan", a.BgCyan("x")) + test("BgLightGray", a.BgLightGray("x")) test("BgGray", a.BgGray("x")) + test("BgLightRed", a.BgLightRed("x")) + test("BgLightGreen", a.BgLightGreen("x")) + test("BgYellow", a.BgYellow("x")) + test("BgLightBlue", a.BgLightBlue("x")) + test("BgLightMagenta", a.BgLightMagenta("x")) + test("BgLightCyan", a.BgLightCyan("x")) + test("BgWhite", a.BgWhite("x")) test("Bold", a.Bold("x")) test("Inverse", a.Inverse("x")) + test("Bright", a.Bright("x")) test("Colorize", a.Colorize("x", RedFg|RedBg)) } @@ -99,7 +116,7 @@ func Test_aurora_methods(t *testing.T) { a := NewAurora(true) test := func(mn string, v Value, clr Color) { if !isColor(v, clr) { - t.Errorf("NewAurora(true).%s wrong color: %d", mn, v.Color()) + t.Errorf("NewAurora(true).%s wrong color: %d expected %d", mn, v.Color(), clr) } else if !isTail(v, 0) { t.Errorf("NewAurora(true).%s unexpected tail value", mn) } else if str, ok := v.Value().(string); !ok { @@ -115,7 +132,15 @@ func Test_aurora_methods(t *testing.T) { test("Blue", a.Blue("x"), BlueFg) test("Magenta", a.Magenta("x"), MagentaFg) test("Cyan", a.Cyan("x"), CyanFg) - test("Gray", a.Gray("x"), GrayFg) + test("LightGray", a.LightGray("x"), GrayFg) + test("Gray", a.Gray("x"), BlackFg|BrightFm) + test("LightRed", a.LightRed("x"), RedFg|BrightFm) + test("LightGreen", a.LightGreen("x"), GreenFg|BrightFm) + test("Yellow", a.Yellow("x"), BrownFg|BrightFm) + test("LightBlue", a.LightBlue("x"), BlueFg|BrightFm) + test("LightMagenta", a.LightMagenta("x"), MagentaFg|BrightFm) + test("LightCyan", a.LightCyan("x"), CyanFg|BrightFm) + test("White", a.White("x"), GrayFg|BrightFm) test("BgBlack", a.BgBlack("x"), BlackBg) test("BgRed", a.BgRed("x"), RedBg) test("BgGreen", a.BgGreen("x"), GreenBg) @@ -123,9 +148,18 @@ func Test_aurora_methods(t *testing.T) { test("BgBlue", a.BgBlue("x"), BlueBg) test("BgMagenta", a.BgMagenta("x"), MagentaBg) test("BgCyan", a.BgCyan("x"), CyanBg) - test("BgGray", a.BgGray("x"), GrayBg) + test("BgLightGray", a.BgLightGray("x"), GrayBg) + test("BgGray", a.BgGray("x"), BlackBg|BrightFm) + test("BgLightRed", a.BgLightRed("x"), RedBg|BrightFm) + test("BgLightGreen", a.BgLightGreen("x"), GreenBg|BrightFm) + test("BgYellow", a.BgYellow("x"), BrownBg|BrightFm) + test("BgLightBlue", a.BgLightBlue("x"), BlueBg|BrightFm) + test("BgLightMagenta", a.BgLightMagenta("x"), MagentaBg|BrightFm) + test("BgLightCyan", a.BgLightCyan("x"), CyanBg|BrightFm) + test("BgWhite", a.BgWhite("x"), GrayBg|BrightFm) test("Bold", a.Bold("x"), BoldFm) test("Inverse", a.Inverse("x"), InverseFm) + test("Bright", a.Bright("x"), BrightFm) test("Colorize", a.Colorize("x", RedFg|RedBg), RedFg|RedBg) } diff --git a/value_test.go b/value_test.go index 2b99ffc..9b50c9a 100644 --- a/value_test.go +++ b/value_test.go @@ -157,7 +157,7 @@ func TestValue_colors(t *testing.T) { test("Blue", BgBlue("x").Blue(), BlueFg|BlueBg) test("Magenta", Magenta("x").Magenta(), MagentaFg) test("Cyan", Red("x").Cyan(), CyanFg) - test("Gray", Green("x").Gray(), GrayFg) + test("LightGray", Green("x").LightGray(), GrayFg) test("BgBlack", Black("x").BgBlack(), BlackFg|BlackBg) test("BgRed", Red("x").BgRed(), RedFg|RedBg) test("BgGreen", Green("x").BgGreen(), GreenFg|GreenBg) @@ -165,7 +165,7 @@ func TestValue_colors(t *testing.T) { test("BgBlue", Blue("x").BgBlue(), BlueFg|BlueBg) test("BgMagenta", BgCyan("x").BgMagenta(), MagentaBg) test("BgCyan", Cyan("x").BgCyan(), CyanFg|CyanBg) - test("BgGray", Gray("x").BgGray(), GrayFg|GrayBg) + test("BgLightGray", LightGray("x").BgLightGray(), GrayFg|GrayBg) test("Bold & BlueBg", Red("x").BgBlue().Bold(), RedFg|BoldFm|BlueBg) test("Inverse", Black("x").Inverse(), BlackFg|InverseFm) // clear @@ -176,7 +176,7 @@ func TestValue_colors(t *testing.T) { test("Blue", valueClear{"x"}.Blue(), 0) test("Magenta", valueClear{"x"}.Magenta(), 0) test("Cyan", valueClear{"x"}.Cyan(), 0) - test("Gray", valueClear{"x"}.Gray(), 0) + test("LightGray", valueClear{"x"}.LightGray(), 0) test("BgBlack", valueClear{"x"}.BgBlack(), 0) test("BgRed", valueClear{"x"}.BgRed(), 0) test("BgGreen", valueClear{"x"}.BgGreen(), 0) @@ -184,7 +184,7 @@ func TestValue_colors(t *testing.T) { test("BgBlue", valueClear{"x"}.BgBlue(), 0) test("BgMagenta", valueClear{"x"}.BgMagenta(), 0) test("BgCyan", valueClear{"x"}.BgCyan(), 0) - test("BgGray", valueClear{"x"}.BgGray(), 0) + test("BgLightGray", valueClear{"x"}.BgLightGray(), 0) test("Bold & BlueBg", valueClear{"x"}.BgBlue().Bold(), 0) test("Inverse", valueClear{"x"}.Inverse(), 0) } diff --git a/wrap_test.go b/wrap_test.go index c21f5c7..f190258 100644 --- a/wrap_test.go +++ b/wrap_test.go @@ -91,9 +91,9 @@ func Test_Cyan(t *testing.T) { CyanFg|CyanBg|BoldFm|InverseFm) } -func Test_Gray(t *testing.T) { - testFunc(t, "Gray", Gray("x"), GrayFg) - testFunc(t, "Complex Gray", Inverse(Bold(BgGray(Gray("x")))), +func Test_LightGray(t *testing.T) { + testFunc(t, "LightGray", LightGray("x"), GrayFg) + testFunc(t, "Complex LightGray", Inverse(Bold(BgLightGray(LightGray("x")))), GrayFg|GrayBg|BoldFm|InverseFm) } @@ -132,9 +132,9 @@ func Test_BgCyan(t *testing.T) { testFunc(t, "Complex BgCyan", Cyan(BgCyan("x")), CyanBg|CyanFg) } -func Test_BgGray(t *testing.T) { - testFunc(t, "BgGray", BgGray("x"), GrayBg) - testFunc(t, "Complex BgGray", Gray(BgGray("x")), GrayBg|GrayFg) +func Test_BgLightGray(t *testing.T) { + testFunc(t, "BgLightGray", BgLightGray("x"), GrayBg) + testFunc(t, "Complex BgLightGray", LightGray(BgLightGray("x")), GrayBg|GrayFg) } func Test_Bold(t *testing.T) { From 40ff49d5def70f12f30bbe7f7bda8df1d8d68cf3 Mon Sep 17 00:00:00 2001 From: Mattias Eriksson Date: Tue, 26 Mar 2019 12:25:34 +0100 Subject: [PATCH 3/6] Add new colors to wrap_test --- wrap_test.go | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/wrap_test.go b/wrap_test.go index f190258..8079f60 100644 --- a/wrap_test.go +++ b/wrap_test.go @@ -97,6 +97,54 @@ func Test_LightGray(t *testing.T) { GrayFg|GrayBg|BoldFm|InverseFm) } +func Test_Gray(t *testing.T) { + testFunc(t, "Gray", Gray("x"), BlackFg|BrightFm) + testFunc(t, "Complex Gray", Inverse(Bold(BgGray(Gray("x")))), + BlackFg|BlackBg|BoldFm|InverseFm|BrightFm) +} + +func Test_LightRed(t *testing.T) { + testFunc(t, "LightRed", LightRed("x"), RedFg|BrightFm) + testFunc(t, "Complex Red", Inverse(Bold(BgLightRed(LightRed("x")))), + RedFg|RedBg|BoldFm|InverseFm|BrightFm) +} + +func Test_LightGreen(t *testing.T) { + testFunc(t, "LightGreen", LightGreen("x"), GreenFg|BrightFm) + testFunc(t, "Complex LightGreen", Inverse(Bold(BgLightGreen(LightGreen("x")))), + GreenFg|GreenBg|BoldFm|InverseFm|BrightFm) +} + +func Test_Yellow(t *testing.T) { + testFunc(t, "Yellow", Yellow("x"), BrownFg|BrightFm) + testFunc(t, "Complex Yellow", Inverse(Bold(BgYellow(Yellow("x")))), + BrownFg|BrownBg|BoldFm|InverseFm|BrightFm) +} + +func Test_LightBlue(t *testing.T) { + testFunc(t, "LightBlue", LightBlue("x"), BlueFg|BrightFm) + testFunc(t, "Complex LightBlue", Inverse(Bold(BgLightBlue(LightBlue("x")))), + BlueFg|BlueBg|BoldFm|InverseFm|BrightFm) +} + +func Test_LightMagenta(t *testing.T) { + testFunc(t, "LightMagenta", LightMagenta("x"), MagentaFg|BrightFm) + testFunc(t, "Complex LightMagenta", Inverse(Bold(BgLightMagenta(LightMagenta("x")))), + MagentaFg|MagentaBg|BoldFm|InverseFm|BrightFm) +} + +func Test_LightCyan(t *testing.T) { + testFunc(t, "LightCyan", LightCyan("x"), CyanFg|BrightFm) + testFunc(t, "Complex LightCyan", Inverse(Bold(BgLightCyan(LightCyan("x")))), + CyanFg|CyanBg|BoldFm|InverseFm|BrightFm) +} + +func Test_White(t *testing.T) { + testFunc(t, "White", White("x"), GrayFg|BrightFm) + testFunc(t, "Complex White", Inverse(Bold(BgWhite(White("x")))), + GrayFg|GrayBg|BoldFm|InverseFm|BrightFm) +} + func Test_BgBlack(t *testing.T) { testFunc(t, "BgBlack", BgBlack("x"), BlackBg) testFunc(t, "Complex BgBlack", Black(BgBlack("x")), BlackBg|BlackFg) @@ -137,6 +185,46 @@ func Test_BgLightGray(t *testing.T) { testFunc(t, "Complex BgLightGray", LightGray(BgLightGray("x")), GrayBg|GrayFg) } +func Test_BgGray(t *testing.T) { + testFunc(t, "BgGray", BgGray("x"), BlackBg|BrightFm) + testFunc(t, "Complex BgGray", Gray(BgGray("x")), BlackBg|BlackFg|BrightFm) +} + +func Test_BgLightRed(t *testing.T) { + testFunc(t, "BgLightRed", BgLightRed("x"), RedBg|BrightFm) + testFunc(t, "Complex BgLightRed", LightRed(BgLightRed("x")), RedBg|RedFg|BrightFm) +} + +func Test_BgLightGreen(t *testing.T) { + testFunc(t, "BgLightGreen", BgLightGreen("x"), GreenBg|BrightFm) + testFunc(t, "Complex BgLightGreen", LightGreen(BgLightGreen("x")), GreenBg|GreenFg|BrightFm) +} + +func Test_BgYellow(t *testing.T) { + testFunc(t, "BgYellow", BgYellow("x"), BrownBg|BrightFm) + testFunc(t, "Complex BgYellow", Yellow(BgYellow("x")), BrownBg|BrownFg|BrightFm) +} + +func Test_BgLightBlue(t *testing.T) { + testFunc(t, "BgLightBlue", BgLightBlue("x"), BlueBg|BrightFm) + testFunc(t, "Complex BgLightBlue", LightBlue(BgLightBlue("x")), BlueBg|BlueFg|BrightFm) +} + +func Test_BgLightMagenta(t *testing.T) { + testFunc(t, "BgLightMagenta", BgLightMagenta("x"), MagentaBg|BrightFm) + testFunc(t, "Complex BgLightMagenta", LightMagenta(BgLightMagenta("x")), MagentaBg|MagentaFg|BrightFm) +} + +func Test_BgLightCyan(t *testing.T) { + testFunc(t, "BgLightCyan", BgLightCyan("x"), CyanBg|BrightFm) + testFunc(t, "Complex BgLightCyan", LightCyan(BgLightCyan("x")), CyanBg|CyanFg|BrightFm) +} + +func Test_BgWhite(t *testing.T) { + testFunc(t, "BgWhite", BgWhite("x"), GrayBg|BrightFm) + testFunc(t, "Complex BgWhite", White(BgWhite("x")), GrayBg|GrayFg|BrightFm) +} + func Test_Bold(t *testing.T) { testFunc(t, "Bold", Bold("x"), BoldFm) } @@ -144,3 +232,7 @@ func Test_Bold(t *testing.T) { func Test_Inverse(t *testing.T) { testFunc(t, "Inverse", Inverse("x"), InverseFm) } + +func Test_Bright(t *testing.T) { + testFunc(t, "Bright", Bright("x"), BrightFm) +} From 39bb9192460795267eec2696ded48154f7f724c6 Mon Sep 17 00:00:00 2001 From: Mattias Eriksson Date: Tue, 26 Mar 2019 12:48:34 +0100 Subject: [PATCH 4/6] Add new colors to value_test --- value_test.go | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/value_test.go b/value_test.go index 9b50c9a..c85d9a8 100644 --- a/value_test.go +++ b/value_test.go @@ -158,6 +158,15 @@ func TestValue_colors(t *testing.T) { test("Magenta", Magenta("x").Magenta(), MagentaFg) test("Cyan", Red("x").Cyan(), CyanFg) test("LightGray", Green("x").LightGray(), GrayFg) + test("Gray", Red("x").Gray(), BlackFg|BrightFm) + test("BrightRed", Bright("x").Red(), RedFg|BrightFm) + test("LightRed", Bold("x").LightRed(), RedFg|BoldFm|BrightFm) + test("LightGreen", Inverse("x").LightGreen(), GreenFg|InverseFm|BrightFm) + test("Inverse&Yellow", Bold("x").Inverse().Yellow(), BoldFm|InverseFm|BrownFg|BrightFm) + test("LightBlue", BgBlue("x").LightBlue(), BlueFg|BlueBg|BrightFm) + test("LightMagenta", Magenta("x").LightMagenta(), MagentaFg|BrightFm) + test("LightCyan", Red("x").LightCyan(), CyanFg|BrightFm) + test("White", Green("x").White(), GrayFg|BrightFm) test("BgBlack", Black("x").BgBlack(), BlackFg|BlackBg) test("BgRed", Red("x").BgRed(), RedFg|RedBg) test("BgGreen", Green("x").BgGreen(), GreenFg|GreenBg) @@ -166,8 +175,17 @@ func TestValue_colors(t *testing.T) { test("BgMagenta", BgCyan("x").BgMagenta(), MagentaBg) test("BgCyan", Cyan("x").BgCyan(), CyanFg|CyanBg) test("BgLightGray", LightGray("x").BgLightGray(), GrayFg|GrayBg) + test("BgGray", Black("x").BgGray(), BlackFg|BlackBg|BrightFm) + test("BgLightRed", LightRed("x").BgLightRed(), RedFg|RedBg|BrightFm) + test("BgLightGreen", LightGreen("x").BgLightGreen(), GreenFg|GreenBg|BrightFm) + test("BgYellow", Yellow("x").BgYellow(), BrownFg|BrownBg|BrightFm) + test("BgLightBlue", LightBlue("x").BgLightBlue(), BlueFg|BlueBg|BrightFm) + test("BgLightMagenta", BgLightCyan("x").BgLightMagenta(), MagentaBg|BrightFm) + test("BgLightCyan", LightCyan("x").BgLightCyan(), CyanFg|CyanBg|BrightFm) + test("BgWhite", White("x").BgWhite(), GrayFg|GrayBg|BrightFm) test("Bold & BlueBg", Red("x").BgBlue().Bold(), RedFg|BoldFm|BlueBg) test("Inverse", Black("x").Inverse(), BlackFg|InverseFm) + test("Bright", Black("x").Bright(), BlackFg|BrightFm) // clear test("Black", valueClear{"x"}.Black(), 0) test("Red", valueClear{"x"}.Red(), 0) @@ -177,6 +195,14 @@ func TestValue_colors(t *testing.T) { test("Magenta", valueClear{"x"}.Magenta(), 0) test("Cyan", valueClear{"x"}.Cyan(), 0) test("LightGray", valueClear{"x"}.LightGray(), 0) + test("Gray", valueClear{"x"}.Gray(), 0) + test("LightRed", valueClear{"x"}.LightRed(), 0) + test("LightGreen", valueClear{"x"}.LightGreen(), 0) + test("Inverse&Yellow", valueClear{"x"}.Inverse().Yellow(), 0) + test("LightBlue", valueClear{"x"}.LightBlue(), 0) + test("LightMagenta", valueClear{"x"}.LightMagenta(), 0) + test("LightCyan", valueClear{"x"}.LightCyan(), 0) + test("White", valueClear{"x"}.White(), 0) test("BgBlack", valueClear{"x"}.BgBlack(), 0) test("BgRed", valueClear{"x"}.BgRed(), 0) test("BgGreen", valueClear{"x"}.BgGreen(), 0) @@ -185,6 +211,15 @@ func TestValue_colors(t *testing.T) { test("BgMagenta", valueClear{"x"}.BgMagenta(), 0) test("BgCyan", valueClear{"x"}.BgCyan(), 0) test("BgLightGray", valueClear{"x"}.BgLightGray(), 0) + test("BgGray", valueClear{"x"}.BgGray(), 0) + test("BgLightRed", valueClear{"x"}.BgLightRed(), 0) + test("BgLightGreen", valueClear{"x"}.BgLightGreen(), 0) + test("BgYellow", valueClear{"x"}.BgYellow(), 0) + test("BgLightBlue", valueClear{"x"}.BgLightBlue(), 0) + test("BgLightMagenta", valueClear{"x"}.BgLightMagenta(), 0) + test("BgLightCyan", valueClear{"x"}.BgLightCyan(), 0) + test("BgWhite", valueClear{"x"}.BgWhite(), 0) test("Bold & BlueBg", valueClear{"x"}.BgBlue().Bold(), 0) test("Inverse", valueClear{"x"}.Inverse(), 0) + test("Bright", valueClear{"x"}.Bright(), 0) } From 7b8eaae3359b42fb149d2dcd9af02a16451debd7 Mon Sep 17 00:00:00 2001 From: Mattias Eriksson Date: Tue, 26 Mar 2019 12:58:50 +0100 Subject: [PATCH 5/6] Add Nos test and another Bright test --- color_test.go | 17 +++++++++++++++++ wrap_test.go | 1 + 2 files changed, 18 insertions(+) diff --git a/color_test.go b/color_test.go index 4f8aefd..e54561e 100644 --- a/color_test.go +++ b/color_test.go @@ -45,3 +45,20 @@ func TestColor_Nos(t *testing.T) { t.Errorf("wrong Nos: want %q, got %q", want, nos) } } + +func TestColor_Nos_Bright(t *testing.T) { + c := Color(0) + if c.Nos() != "" { + t.Error("some Nos for 0 color") + } + c = BoldFm | InverseFm | RedFg | MagentaBg | BrightFm + want := "1;7;91;105" + if nos := c.Nos(); nos != want { + t.Errorf("wrong Nos: want %q, got %q", want, nos) + } + c = InverseFm | BlackBg | BrightFm + want = "7;100" + if nos := c.Nos(); nos != want { + t.Errorf("wrong Nos: want %q, got %q", want, nos) + } +} diff --git a/wrap_test.go b/wrap_test.go index 8079f60..b3cd86d 100644 --- a/wrap_test.go +++ b/wrap_test.go @@ -99,6 +99,7 @@ func Test_LightGray(t *testing.T) { func Test_Gray(t *testing.T) { testFunc(t, "Gray", Gray("x"), BlackFg|BrightFm) + testFunc(t, "BrightBlack", Bright(Black("x")), BlackFg|BrightFm) testFunc(t, "Complex Gray", Inverse(Bold(BgGray(Gray("x")))), BlackFg|BlackBg|BoldFm|InverseFm|BrightFm) } From cb65dd3a3a553c6e2668c525dcb3b8a019c2adbc Mon Sep 17 00:00:00 2001 From: Mattias Eriksson Date: Mon, 1 Apr 2019 14:16:57 +0200 Subject: [PATCH 6/6] Separate BrightFm to FgBrightFm and BgBrightFm Also removed the Bright function, it is not really useful on its own. --- aurora.go | 3 --- aurora_test.go | 34 +++++++++++------------ color.go | 13 ++++----- color_test.go | 11 +++++--- value.go | 39 +++++++++++---------------- value_test.go | 36 ++++++++++++------------- wrap.go | 73 ++++++++++++++++++++++---------------------------- wrap_test.go | 69 ++++++++++++++++++++++------------------------- 8 files changed, 128 insertions(+), 150 deletions(-) diff --git a/aurora.go b/aurora.go index 5ad98b3..2d97499 100644 --- a/aurora.go +++ b/aurora.go @@ -67,7 +67,6 @@ type Aurora interface { BgWhite(arg interface{}) Value Bold(arg interface{}) Value Inverse(arg interface{}) Value - Bright(arg interface{}) Value Colorize(arg interface{}, color Color) Value Sprintf(format interface{}, args ...interface{}) string } @@ -120,7 +119,6 @@ func (auroraClear) BgLightCyan(arg interface{}) Value { return valueClear{arg func (auroraClear) BgWhite(arg interface{}) Value { return valueClear{arg} } func (auroraClear) Bold(arg interface{}) Value { return valueClear{arg} } func (auroraClear) Inverse(arg interface{}) Value { return valueClear{arg} } -func (auroraClear) Bright(arg interface{}) Value { return valueClear{arg} } func (auroraClear) Colorize(arg interface{}, color Color) Value { return valueClear{arg} @@ -171,7 +169,6 @@ func (aurora) BgLightCyan(arg interface{}) Value { return BgLightCyan(arg) } func (aurora) BgWhite(arg interface{}) Value { return BgWhite(arg) } func (aurora) Bold(arg interface{}) Value { return Bold(arg) } func (aurora) Inverse(arg interface{}) Value { return Inverse(arg) } -func (aurora) Bright(arg interface{}) Value { return Bright(arg) } func (aurora) Colorize(arg interface{}, color Color) Value { return Colorize(arg, color) diff --git a/aurora_test.go b/aurora_test.go index 6d114c0..16de447 100644 --- a/aurora_test.go +++ b/aurora_test.go @@ -98,7 +98,6 @@ func Test_auroraClear_methods(t *testing.T) { test("BgWhite", a.BgWhite("x")) test("Bold", a.Bold("x")) test("Inverse", a.Inverse("x")) - test("Bright", a.Bright("x")) test("Colorize", a.Colorize("x", RedFg|RedBg)) } @@ -133,14 +132,14 @@ func Test_aurora_methods(t *testing.T) { test("Magenta", a.Magenta("x"), MagentaFg) test("Cyan", a.Cyan("x"), CyanFg) test("LightGray", a.LightGray("x"), GrayFg) - test("Gray", a.Gray("x"), BlackFg|BrightFm) - test("LightRed", a.LightRed("x"), RedFg|BrightFm) - test("LightGreen", a.LightGreen("x"), GreenFg|BrightFm) - test("Yellow", a.Yellow("x"), BrownFg|BrightFm) - test("LightBlue", a.LightBlue("x"), BlueFg|BrightFm) - test("LightMagenta", a.LightMagenta("x"), MagentaFg|BrightFm) - test("LightCyan", a.LightCyan("x"), CyanFg|BrightFm) - test("White", a.White("x"), GrayFg|BrightFm) + test("Gray", a.Gray("x"), BlackFg|FgBrightFm) + test("LightRed", a.LightRed("x"), RedFg|FgBrightFm) + test("LightGreen", a.LightGreen("x"), GreenFg|FgBrightFm) + test("Yellow", a.Yellow("x"), BrownFg|FgBrightFm) + test("LightBlue", a.LightBlue("x"), BlueFg|FgBrightFm) + test("LightMagenta", a.LightMagenta("x"), MagentaFg|FgBrightFm) + test("LightCyan", a.LightCyan("x"), CyanFg|FgBrightFm) + test("White", a.White("x"), GrayFg|FgBrightFm) test("BgBlack", a.BgBlack("x"), BlackBg) test("BgRed", a.BgRed("x"), RedBg) test("BgGreen", a.BgGreen("x"), GreenBg) @@ -149,17 +148,16 @@ func Test_aurora_methods(t *testing.T) { test("BgMagenta", a.BgMagenta("x"), MagentaBg) test("BgCyan", a.BgCyan("x"), CyanBg) test("BgLightGray", a.BgLightGray("x"), GrayBg) - test("BgGray", a.BgGray("x"), BlackBg|BrightFm) - test("BgLightRed", a.BgLightRed("x"), RedBg|BrightFm) - test("BgLightGreen", a.BgLightGreen("x"), GreenBg|BrightFm) - test("BgYellow", a.BgYellow("x"), BrownBg|BrightFm) - test("BgLightBlue", a.BgLightBlue("x"), BlueBg|BrightFm) - test("BgLightMagenta", a.BgLightMagenta("x"), MagentaBg|BrightFm) - test("BgLightCyan", a.BgLightCyan("x"), CyanBg|BrightFm) - test("BgWhite", a.BgWhite("x"), GrayBg|BrightFm) + test("BgGray", a.BgGray("x"), BlackBg|BgBrightFm) + test("BgLightRed", a.BgLightRed("x"), RedBg|BgBrightFm) + test("BgLightGreen", a.BgLightGreen("x"), GreenBg|BgBrightFm) + test("BgYellow", a.BgYellow("x"), BrownBg|BgBrightFm) + test("BgLightBlue", a.BgLightBlue("x"), BlueBg|BgBrightFm) + test("BgLightMagenta", a.BgLightMagenta("x"), MagentaBg|BgBrightFm) + test("BgLightCyan", a.BgLightCyan("x"), CyanBg|BgBrightFm) + test("BgWhite", a.BgWhite("x"), GrayBg|BgBrightFm) test("Bold", a.Bold("x"), BoldFm) test("Inverse", a.Inverse("x"), InverseFm) - test("Bright", a.Bright("x"), BrightFm) test("Colorize", a.Colorize("x", RedFg|RedBg), RedFg|RedBg) } diff --git a/color.go b/color.go index 898f960..0248588 100644 --- a/color.go +++ b/color.go @@ -32,9 +32,10 @@ type Color int // special formats const ( - BoldFm Color = 1 << iota // bold - InverseFm // inverse - BrightFm // bright + BoldFm Color = 1 << iota // bold + InverseFm // inverse + FgBrightFm // bright foreground + BgBrightFm // bright background ) // foreground @@ -69,7 +70,7 @@ const ( // IsValid returns true if a color looks like valid func (c Color) IsValid() bool { - return c&(BrightFm|BoldFm|InverseFm|maskFg|maskBg) != 0 || c == 0 + return c&(BgBrightFm|FgBrightFm|BoldFm|InverseFm|maskFg|maskBg) != 0 || c == 0 } const ( @@ -107,7 +108,7 @@ func (c Color) appendNos(bs []byte) []byte { } else { semicolon = true } - if c&BrightFm != 0 { + if c&FgBrightFm != 0 { bs = append(bs, '9', '0'+byte((c>>8)&0xff)-1) } else { bs = append(bs, '3', '0'+byte((c>>8)&0xff)-1) @@ -117,7 +118,7 @@ func (c Color) appendNos(bs []byte) []byte { if semicolon { bs = append(bs, ';') } - if c&BrightFm != 0 { + if c&BgBrightFm != 0 { bs = append(bs, '1', '0', '0'+byte((c>>16)&0xff)-1) } else { bs = append(bs, '4', '0'+byte((c>>16)&0xff)-1) diff --git a/color_test.go b/color_test.go index e54561e..a111715 100644 --- a/color_test.go +++ b/color_test.go @@ -51,14 +51,19 @@ func TestColor_Nos_Bright(t *testing.T) { if c.Nos() != "" { t.Error("some Nos for 0 color") } - c = BoldFm | InverseFm | RedFg | MagentaBg | BrightFm - want := "1;7;91;105" + c = BoldFm | InverseFm | RedFg | MagentaBg | FgBrightFm + want := "1;7;91;45" if nos := c.Nos(); nos != want { t.Errorf("wrong Nos: want %q, got %q", want, nos) } - c = InverseFm | BlackBg | BrightFm + c = InverseFm | BlackBg | BgBrightFm want = "7;100" if nos := c.Nos(); nos != want { t.Errorf("wrong Nos: want %q, got %q", want, nos) } + c = InverseFm | CyanBg | RedFg | FgBrightFm | BgBrightFm + want = "7;91;106" + if nos := c.Nos(); nos != want { + t.Errorf("wrong Nos: want %q, got %q", want, nos) + } } diff --git a/value.go b/value.go index 1b8a447..16fe4cd 100644 --- a/value.go +++ b/value.go @@ -83,7 +83,6 @@ type Value interface { BgWhite() Value // change background color to white Bold() Value // change format to bold Inverse() Value // change format to inversed - Bright() Value // change format to bright } // Value without colors @@ -133,7 +132,6 @@ func (v valueClear) BgLightCyan() Value { return v } func (v valueClear) BgWhite() Value { return v } func (v valueClear) Bold() Value { return v } func (v valueClear) Inverse() Value { return v } -func (v valueClear) Bright() Value { return v } func (v valueClear) Format(s fmt.State, verb rune) { // it's enough for many cases (%-+020.10f) @@ -301,42 +299,42 @@ func (v value) LightGray() Value { //This is really bright black func (v value) Gray() Value { - v.color = (v.color & (^maskFg)) | BlackFg | BrightFm + v.color = (v.color & (^maskFg)) | BlackFg | FgBrightFm return v } func (v value) LightRed() Value { - v.color = (v.color & (^maskFg)) | RedFg | BrightFm + v.color = (v.color & (^maskFg)) | RedFg | FgBrightFm return v } func (v value) LightGreen() Value { - v.color = (v.color & (^maskFg)) | GreenFg | BrightFm + v.color = (v.color & (^maskFg)) | GreenFg | FgBrightFm return v } func (v value) Yellow() Value { - v.color = (v.color & (^maskFg)) | BrownFg | BrightFm + v.color = (v.color & (^maskFg)) | BrownFg | FgBrightFm return v } func (v value) LightBlue() Value { - v.color = (v.color & (^maskFg)) | BlueFg | BrightFm + v.color = (v.color & (^maskFg)) | BlueFg | FgBrightFm return v } func (v value) LightMagenta() Value { - v.color = (v.color & (^maskFg)) | MagentaFg | BrightFm + v.color = (v.color & (^maskFg)) | MagentaFg | FgBrightFm return v } func (v value) LightCyan() Value { - v.color = (v.color & (^maskFg)) | CyanFg | BrightFm + v.color = (v.color & (^maskFg)) | CyanFg | FgBrightFm return v } func (v value) White() Value { - v.color = (v.color & (^maskFg)) | GrayFg | BrightFm + v.color = (v.color & (^maskFg)) | GrayFg | FgBrightFm return v } @@ -383,42 +381,42 @@ func (v value) BgLightGray() Value { //This is really light black func (v value) BgGray() Value { - v.color = (v.color & (^maskBg)) | BlackBg | BrightFm + v.color = (v.color & (^maskBg)) | BlackBg | BgBrightFm return v } func (v value) BgLightRed() Value { - v.color = (v.color & (^maskBg)) | RedBg | BrightFm + v.color = (v.color & (^maskBg)) | RedBg | BgBrightFm return v } func (v value) BgLightGreen() Value { - v.color = (v.color & (^maskBg)) | GreenBg | BrightFm + v.color = (v.color & (^maskBg)) | GreenBg | BgBrightFm return v } func (v value) BgYellow() Value { - v.color = (v.color & (^maskBg)) | BrownBg | BrightFm + v.color = (v.color & (^maskBg)) | BrownBg | BgBrightFm return v } func (v value) BgLightBlue() Value { - v.color = (v.color & (^maskBg)) | BlueBg | BrightFm + v.color = (v.color & (^maskBg)) | BlueBg | BgBrightFm return v } func (v value) BgLightMagenta() Value { - v.color = (v.color & (^maskBg)) | MagentaBg | BrightFm + v.color = (v.color & (^maskBg)) | MagentaBg | BgBrightFm return v } func (v value) BgLightCyan() Value { - v.color = (v.color & (^maskBg)) | CyanBg | BrightFm + v.color = (v.color & (^maskBg)) | CyanBg | BgBrightFm return v } func (v value) BgWhite() Value { - v.color = (v.color & (^maskBg)) | GrayBg | BrightFm + v.color = (v.color & (^maskBg)) | GrayBg | BgBrightFm return v } @@ -431,8 +429,3 @@ func (v value) Inverse() Value { v.color |= InverseFm return v } - -func (v value) Bright() Value { - v.color |= BrightFm - return v -} diff --git a/value_test.go b/value_test.go index c85d9a8..404b769 100644 --- a/value_test.go +++ b/value_test.go @@ -158,15 +158,15 @@ func TestValue_colors(t *testing.T) { test("Magenta", Magenta("x").Magenta(), MagentaFg) test("Cyan", Red("x").Cyan(), CyanFg) test("LightGray", Green("x").LightGray(), GrayFg) - test("Gray", Red("x").Gray(), BlackFg|BrightFm) - test("BrightRed", Bright("x").Red(), RedFg|BrightFm) - test("LightRed", Bold("x").LightRed(), RedFg|BoldFm|BrightFm) - test("LightGreen", Inverse("x").LightGreen(), GreenFg|InverseFm|BrightFm) - test("Inverse&Yellow", Bold("x").Inverse().Yellow(), BoldFm|InverseFm|BrownFg|BrightFm) - test("LightBlue", BgBlue("x").LightBlue(), BlueFg|BlueBg|BrightFm) - test("LightMagenta", Magenta("x").LightMagenta(), MagentaFg|BrightFm) - test("LightCyan", Red("x").LightCyan(), CyanFg|BrightFm) - test("White", Green("x").White(), GrayFg|BrightFm) + test("Gray", Red("x").Gray(), BlackFg|FgBrightFm) + test("BrightRed", LightRed("x"), RedFg|FgBrightFm) + test("LightRed", Bold("x").LightRed(), RedFg|BoldFm|FgBrightFm) + test("LightGreen", Inverse("x").LightGreen(), GreenFg|InverseFm|FgBrightFm) + test("Inverse&Yellow", Bold("x").Inverse().Yellow(), BoldFm|InverseFm|BrownFg|FgBrightFm) + test("LightBlue", BgBlue("x").LightBlue(), BlueFg|BlueBg|FgBrightFm) + test("LightMagenta", Magenta("x").LightMagenta(), MagentaFg|FgBrightFm) + test("LightCyan", Red("x").LightCyan(), CyanFg|FgBrightFm) + test("White", Green("x").White(), GrayFg|FgBrightFm) test("BgBlack", Black("x").BgBlack(), BlackFg|BlackBg) test("BgRed", Red("x").BgRed(), RedFg|RedBg) test("BgGreen", Green("x").BgGreen(), GreenFg|GreenBg) @@ -175,17 +175,16 @@ func TestValue_colors(t *testing.T) { test("BgMagenta", BgCyan("x").BgMagenta(), MagentaBg) test("BgCyan", Cyan("x").BgCyan(), CyanFg|CyanBg) test("BgLightGray", LightGray("x").BgLightGray(), GrayFg|GrayBg) - test("BgGray", Black("x").BgGray(), BlackFg|BlackBg|BrightFm) - test("BgLightRed", LightRed("x").BgLightRed(), RedFg|RedBg|BrightFm) - test("BgLightGreen", LightGreen("x").BgLightGreen(), GreenFg|GreenBg|BrightFm) - test("BgYellow", Yellow("x").BgYellow(), BrownFg|BrownBg|BrightFm) - test("BgLightBlue", LightBlue("x").BgLightBlue(), BlueFg|BlueBg|BrightFm) - test("BgLightMagenta", BgLightCyan("x").BgLightMagenta(), MagentaBg|BrightFm) - test("BgLightCyan", LightCyan("x").BgLightCyan(), CyanFg|CyanBg|BrightFm) - test("BgWhite", White("x").BgWhite(), GrayFg|GrayBg|BrightFm) + test("BgGray", Black("x").BgGray(), BlackFg|BlackBg|BgBrightFm) + test("BgLightRed", LightRed("x").BgLightRed(), RedFg|RedBg|BgBrightFm|FgBrightFm) + test("BgLightGreen", LightGreen("x").BgLightGreen(), GreenFg|GreenBg|BgBrightFm|FgBrightFm) + test("BgYellow", Yellow("x").BgYellow(), BrownFg|BrownBg|BgBrightFm|FgBrightFm) + test("BgLightBlue", LightBlue("x").BgLightBlue(), BlueFg|BlueBg|BgBrightFm|FgBrightFm) + test("BgLightMagenta", BgLightCyan("x").BgLightMagenta(), MagentaBg|BgBrightFm) + test("BgLightCyan", LightCyan("x").BgLightCyan(), CyanFg|CyanBg|BgBrightFm|FgBrightFm) + test("BgWhite", White("x").BgWhite(), GrayFg|GrayBg|BgBrightFm|FgBrightFm) test("Bold & BlueBg", Red("x").BgBlue().Bold(), RedFg|BoldFm|BlueBg) test("Inverse", Black("x").Inverse(), BlackFg|InverseFm) - test("Bright", Black("x").Bright(), BlackFg|BrightFm) // clear test("Black", valueClear{"x"}.Black(), 0) test("Red", valueClear{"x"}.Red(), 0) @@ -221,5 +220,4 @@ func TestValue_colors(t *testing.T) { test("BgWhite", valueClear{"x"}.BgWhite(), 0) test("Bold & BlueBg", valueClear{"x"}.BgBlue().Bold(), 0) test("Inverse", valueClear{"x"}.Inverse(), 0) - test("Bright", valueClear{"x"}.Bright(), 0) } diff --git a/wrap.go b/wrap.go index 3a0b538..64217e2 100644 --- a/wrap.go +++ b/wrap.go @@ -125,73 +125,73 @@ func LightGray(arg interface{}) Value { // Gray converts argument into formated/colorized value func Gray(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | BlackFg | BrightFm + val.color = (val.color & (^maskFg)) | BlackFg | FgBrightFm return val } - return value{arg, BlackFg | BrightFm, 0} + return value{arg, BlackFg | FgBrightFm, 0} } // LightRed converts argument into formated/colorized value func LightRed(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | RedFg | BrightFm + val.color = (val.color & (^maskFg)) | RedFg | FgBrightFm return val } - return value{arg, RedFg | BrightFm, 0} + return value{arg, RedFg | FgBrightFm, 0} } // LightGreen converts argument into formated/colorized value func LightGreen(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | GreenFg | BrightFm + val.color = (val.color & (^maskFg)) | GreenFg | FgBrightFm return val } - return value{arg, GreenFg | BrightFm, 0} + return value{arg, GreenFg | FgBrightFm, 0} } // Yellow converts argument into formated/colorized value func Yellow(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | BrownFg | BrightFm + val.color = (val.color & (^maskFg)) | BrownFg | FgBrightFm return val } - return value{arg, BrownFg | BrightFm, 0} + return value{arg, BrownFg | FgBrightFm, 0} } // LightBlue converts argument into formated/colorized value func LightBlue(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | BlueFg | BrightFm + val.color = (val.color & (^maskFg)) | BlueFg | FgBrightFm return val } - return value{arg, BlueFg | BrightFm, 0} + return value{arg, BlueFg | FgBrightFm, 0} } // LightMagenta converts argument into formated/colorized value func LightMagenta(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | MagentaFg | BrightFm + val.color = (val.color & (^maskFg)) | MagentaFg | FgBrightFm return val } - return value{arg, MagentaFg | BrightFm, 0} + return value{arg, MagentaFg | FgBrightFm, 0} } // LightCyan converts argument into formated/colorized value func LightCyan(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | CyanFg | BrightFm + val.color = (val.color & (^maskFg)) | CyanFg | FgBrightFm return val } - return value{arg, CyanFg | BrightFm, 0} + return value{arg, CyanFg | FgBrightFm, 0} } // White converts argument into formated/colorized value func White(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskFg)) | GrayFg | BrightFm + val.color = (val.color & (^maskFg)) | GrayFg | FgBrightFm return val } - return value{arg, GrayFg | BrightFm, 0} + return value{arg, GrayFg | FgBrightFm, 0} } // @@ -273,82 +273,73 @@ func BgLightGray(arg interface{}) Value { // BgGray converts argument into formated/colorized value func BgGray(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | BlackBg | BrightFm + val.color = (val.color & (^maskBg)) | BlackBg | BgBrightFm return val } - return value{arg, BlackBg | BrightFm, 0} + return value{arg, BlackBg | BgBrightFm, 0} } // BgLightRed converts argument into formated/colorized value func BgLightRed(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | RedBg | BrightFm + val.color = (val.color & (^maskBg)) | RedBg | BgBrightFm return val } - return value{arg, RedBg | BrightFm, 0} + return value{arg, RedBg | BgBrightFm, 0} } // BgLightGreen converts argument into formated/colorized value func BgLightGreen(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | GreenBg | BrightFm + val.color = (val.color & (^maskBg)) | GreenBg | BgBrightFm return val } - return value{arg, GreenBg | BrightFm, 0} + return value{arg, GreenBg | BgBrightFm, 0} } // BgYellow converts argument into formated/colorized value func BgYellow(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | BrownBg | BrightFm + val.color = (val.color & (^maskBg)) | BrownBg | BgBrightFm return val } - return value{arg, BrownBg | BrightFm, 0} + return value{arg, BrownBg | BgBrightFm, 0} } // BgLightBlue converts argument into formated/colorized value func BgLightBlue(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | BlueBg | BrightFm + val.color = (val.color & (^maskBg)) | BlueBg | BgBrightFm return val } - return value{arg, BlueBg | BrightFm, 0} + return value{arg, BlueBg | BgBrightFm, 0} } // BgLightMagenta converts argument into formated/colorized value func BgLightMagenta(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | MagentaBg | BrightFm + val.color = (val.color & (^maskBg)) | MagentaBg | BgBrightFm return val } - return value{arg, MagentaBg | BrightFm, 0} + return value{arg, MagentaBg | BgBrightFm, 0} } // BgLightCyan converts argument into formated/colorized value func BgLightCyan(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | CyanBg | BrightFm + val.color = (val.color & (^maskBg)) | CyanBg | BgBrightFm return val } - return value{arg, CyanBg | BrightFm, 0} + return value{arg, CyanBg | BgBrightFm, 0} } // BgWhtie converts argument into formated/colorized value func BgWhite(arg interface{}) Value { if val, ok := arg.(value); ok { - val.color = (val.color & (^maskBg)) | GrayBg | BrightFm + val.color = (val.color & (^maskBg)) | GrayBg | BgBrightFm return val } - return value{arg, GrayBg | BrightFm, 0} -} - -// Bright converts argument into formated/colorized value -func Bright(arg interface{}) Value { - if val, ok := arg.(value); ok { - val.color |= BrightFm - return val - } - return value{arg, BrightFm, 0} + return value{arg, GrayBg | BgBrightFm, 0} } // Bold converts argument into formated/colorized value diff --git a/wrap_test.go b/wrap_test.go index b3cd86d..9994f1d 100644 --- a/wrap_test.go +++ b/wrap_test.go @@ -98,52 +98,51 @@ func Test_LightGray(t *testing.T) { } func Test_Gray(t *testing.T) { - testFunc(t, "Gray", Gray("x"), BlackFg|BrightFm) - testFunc(t, "BrightBlack", Bright(Black("x")), BlackFg|BrightFm) + testFunc(t, "Gray", Gray("x"), BlackFg|FgBrightFm) testFunc(t, "Complex Gray", Inverse(Bold(BgGray(Gray("x")))), - BlackFg|BlackBg|BoldFm|InverseFm|BrightFm) + BlackFg|BlackBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_LightRed(t *testing.T) { - testFunc(t, "LightRed", LightRed("x"), RedFg|BrightFm) + testFunc(t, "LightRed", LightRed("x"), RedFg|FgBrightFm) testFunc(t, "Complex Red", Inverse(Bold(BgLightRed(LightRed("x")))), - RedFg|RedBg|BoldFm|InverseFm|BrightFm) + RedFg|RedBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_LightGreen(t *testing.T) { - testFunc(t, "LightGreen", LightGreen("x"), GreenFg|BrightFm) + testFunc(t, "LightGreen", LightGreen("x"), GreenFg|FgBrightFm) testFunc(t, "Complex LightGreen", Inverse(Bold(BgLightGreen(LightGreen("x")))), - GreenFg|GreenBg|BoldFm|InverseFm|BrightFm) + GreenFg|GreenBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_Yellow(t *testing.T) { - testFunc(t, "Yellow", Yellow("x"), BrownFg|BrightFm) + testFunc(t, "Yellow", Yellow("x"), BrownFg|FgBrightFm) testFunc(t, "Complex Yellow", Inverse(Bold(BgYellow(Yellow("x")))), - BrownFg|BrownBg|BoldFm|InverseFm|BrightFm) + BrownFg|BrownBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_LightBlue(t *testing.T) { - testFunc(t, "LightBlue", LightBlue("x"), BlueFg|BrightFm) + testFunc(t, "LightBlue", LightBlue("x"), BlueFg|FgBrightFm) testFunc(t, "Complex LightBlue", Inverse(Bold(BgLightBlue(LightBlue("x")))), - BlueFg|BlueBg|BoldFm|InverseFm|BrightFm) + BlueFg|BlueBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_LightMagenta(t *testing.T) { - testFunc(t, "LightMagenta", LightMagenta("x"), MagentaFg|BrightFm) + testFunc(t, "LightMagenta", LightMagenta("x"), MagentaFg|FgBrightFm) testFunc(t, "Complex LightMagenta", Inverse(Bold(BgLightMagenta(LightMagenta("x")))), - MagentaFg|MagentaBg|BoldFm|InverseFm|BrightFm) + MagentaFg|MagentaBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_LightCyan(t *testing.T) { - testFunc(t, "LightCyan", LightCyan("x"), CyanFg|BrightFm) + testFunc(t, "LightCyan", LightCyan("x"), CyanFg|FgBrightFm) testFunc(t, "Complex LightCyan", Inverse(Bold(BgLightCyan(LightCyan("x")))), - CyanFg|CyanBg|BoldFm|InverseFm|BrightFm) + CyanFg|CyanBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_White(t *testing.T) { - testFunc(t, "White", White("x"), GrayFg|BrightFm) + testFunc(t, "White", White("x"), GrayFg|FgBrightFm) testFunc(t, "Complex White", Inverse(Bold(BgWhite(White("x")))), - GrayFg|GrayBg|BoldFm|InverseFm|BrightFm) + GrayFg|GrayBg|BoldFm|InverseFm|FgBrightFm|BgBrightFm) } func Test_BgBlack(t *testing.T) { @@ -187,43 +186,43 @@ func Test_BgLightGray(t *testing.T) { } func Test_BgGray(t *testing.T) { - testFunc(t, "BgGray", BgGray("x"), BlackBg|BrightFm) - testFunc(t, "Complex BgGray", Gray(BgGray("x")), BlackBg|BlackFg|BrightFm) + testFunc(t, "BgGray", BgGray("x"), BlackBg|BgBrightFm) + testFunc(t, "Complex BgGray", Gray(BgGray("x")), BlackBg|BlackFg|BgBrightFm|FgBrightFm) } func Test_BgLightRed(t *testing.T) { - testFunc(t, "BgLightRed", BgLightRed("x"), RedBg|BrightFm) - testFunc(t, "Complex BgLightRed", LightRed(BgLightRed("x")), RedBg|RedFg|BrightFm) + testFunc(t, "BgLightRed", BgLightRed("x"), RedBg|BgBrightFm) + testFunc(t, "Complex BgLightRed", LightRed(BgLightRed("x")), RedBg|RedFg|BgBrightFm|FgBrightFm) } func Test_BgLightGreen(t *testing.T) { - testFunc(t, "BgLightGreen", BgLightGreen("x"), GreenBg|BrightFm) - testFunc(t, "Complex BgLightGreen", LightGreen(BgLightGreen("x")), GreenBg|GreenFg|BrightFm) + testFunc(t, "BgLightGreen", BgLightGreen("x"), GreenBg|BgBrightFm) + testFunc(t, "Complex BgLightGreen", LightGreen(BgLightGreen("x")), GreenBg|GreenFg|BgBrightFm|FgBrightFm) } func Test_BgYellow(t *testing.T) { - testFunc(t, "BgYellow", BgYellow("x"), BrownBg|BrightFm) - testFunc(t, "Complex BgYellow", Yellow(BgYellow("x")), BrownBg|BrownFg|BrightFm) + testFunc(t, "BgYellow", BgYellow("x"), BrownBg|BgBrightFm) + testFunc(t, "Complex BgYellow", Yellow(BgYellow("x")), BrownBg|BrownFg|BgBrightFm|FgBrightFm) } func Test_BgLightBlue(t *testing.T) { - testFunc(t, "BgLightBlue", BgLightBlue("x"), BlueBg|BrightFm) - testFunc(t, "Complex BgLightBlue", LightBlue(BgLightBlue("x")), BlueBg|BlueFg|BrightFm) + testFunc(t, "BgLightBlue", BgLightBlue("x"), BlueBg|BgBrightFm) + testFunc(t, "Complex BgLightBlue", LightBlue(BgLightBlue("x")), BlueBg|BlueFg|BgBrightFm|FgBrightFm) } func Test_BgLightMagenta(t *testing.T) { - testFunc(t, "BgLightMagenta", BgLightMagenta("x"), MagentaBg|BrightFm) - testFunc(t, "Complex BgLightMagenta", LightMagenta(BgLightMagenta("x")), MagentaBg|MagentaFg|BrightFm) + testFunc(t, "BgLightMagenta", BgLightMagenta("x"), MagentaBg|BgBrightFm) + testFunc(t, "Complex BgLightMagenta", LightMagenta(BgLightMagenta("x")), MagentaBg|MagentaFg|BgBrightFm|FgBrightFm) } func Test_BgLightCyan(t *testing.T) { - testFunc(t, "BgLightCyan", BgLightCyan("x"), CyanBg|BrightFm) - testFunc(t, "Complex BgLightCyan", LightCyan(BgLightCyan("x")), CyanBg|CyanFg|BrightFm) + testFunc(t, "BgLightCyan", BgLightCyan("x"), CyanBg|BgBrightFm) + testFunc(t, "Complex BgLightCyan", LightCyan(BgLightCyan("x")), CyanBg|CyanFg|BgBrightFm|FgBrightFm) } func Test_BgWhite(t *testing.T) { - testFunc(t, "BgWhite", BgWhite("x"), GrayBg|BrightFm) - testFunc(t, "Complex BgWhite", White(BgWhite("x")), GrayBg|GrayFg|BrightFm) + testFunc(t, "BgWhite", BgWhite("x"), GrayBg|BgBrightFm) + testFunc(t, "Complex BgWhite", White(BgWhite("x")), GrayBg|GrayFg|BgBrightFm|FgBrightFm) } func Test_Bold(t *testing.T) { @@ -233,7 +232,3 @@ func Test_Bold(t *testing.T) { func Test_Inverse(t *testing.T) { testFunc(t, "Inverse", Inverse("x"), InverseFm) } - -func Test_Bright(t *testing.T) { - testFunc(t, "Bright", Bright("x"), BrightFm) -}