pax_global_header00006660000000000000000000000064127741406120014516gustar00rootroot0000000000000052 comment=dea9d3a26a087187530244679c1cfb3a42937794 color-1.1.0/000077500000000000000000000000001277414061200126335ustar00rootroot00000000000000color-1.1.0/.travis.yml000066400000000000000000000000411277414061200147370ustar00rootroot00000000000000language: go go: - 1.6 - tip color-1.1.0/LICENSE.md000066400000000000000000000020671277414061200142440ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2013 Fatih Arslan Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. color-1.1.0/README.md000066400000000000000000000077361277414061200141270ustar00rootroot00000000000000# Color [![GoDoc](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](http://godoc.org/github.com/fatih/color) [![Build Status](http://img.shields.io/travis/fatih/color.svg?style=flat-square)](https://travis-ci.org/fatih/color) Color lets you use colorized outputs in terms of [ANSI Escape Codes](http://en.wikipedia.org/wiki/ANSI_escape_code#Colors) in Go (Golang). It has support for Windows too! The API can be used in several ways, pick one that suits you. ![Color](http://i.imgur.com/c1JI0lA.png) ## Install ```bash go get github.com/fatih/color ``` ## Examples ### Standard colors ```go // Print with default helper functions color.Cyan("Prints text in cyan.") // A newline will be appended automatically color.Blue("Prints %s in blue.", "text") // These are using the default foreground colors color.Red("We have red") color.Magenta("And many others ..") ``` ### Mix and reuse colors ```go // Create a new color object c := color.New(color.FgCyan).Add(color.Underline) c.Println("Prints cyan text with an underline.") // Or just add them to New() d := color.New(color.FgCyan, color.Bold) d.Printf("This prints bold cyan %s\n", "too!.") // Mix up foreground and background colors, create new mixes! red := color.New(color.FgRed) boldRed := red.Add(color.Bold) boldRed.Println("This will print text in bold red.") whiteBackground := red.Add(color.BgWhite) whiteBackground.Println("Red text with white background.") ``` ### Custom print functions (PrintFunc) ```go // Create a custom print function for convenience red := color.New(color.FgRed).PrintfFunc() red("Warning") red("Error: %s", err) // Mix up multiple attributes notice := color.New(color.Bold, color.FgGreen).PrintlnFunc() notice("Don't forget this...") ``` ### Insert into noncolor strings (SprintFunc) ```go // Create SprintXxx functions to mix strings with other non-colorized strings: yellow := color.New(color.FgYellow).SprintFunc() red := color.New(color.FgRed).SprintFunc() fmt.Printf("This is a %s and this is %s.\n", yellow("warning"), red("error")) info := color.New(color.FgWhite, color.BgGreen).SprintFunc() fmt.Printf("This %s rocks!\n", info("package")) // Use helper functions fmt.Println("This", color.RedString("warning"), "should be not neglected.") fmt.Printf("%v %v\n", color.GreenString("Info:"), "an important message.") // Windows supported too! Just don't forget to change the output to color.Output fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS")) ``` ### Plug into existing code ```go // Use handy standard colors color.Set(color.FgYellow) fmt.Println("Existing text will now be in yellow") fmt.Printf("This one %s\n", "too") color.Unset() // Don't forget to unset // You can mix up parameters color.Set(color.FgMagenta, color.Bold) defer color.Unset() // Use it in your function fmt.Println("All text will now be bold magenta.") ``` ### Disable color There might be a case where you want to disable color output (for example to pipe the standard output of your app to somewhere else). `Color` has support to disable colors both globally and for single color definition. For example suppose you have a CLI app and a `--no-color` bool flag. You can easily disable the color output with: ```go var flagNoColor = flag.Bool("no-color", false, "Disable color output") if *flagNoColor { color.NoColor = true // disables colorized output } ``` It also has support for single color definitions (local). You can disable/enable color output on the fly: ```go c := color.New(color.FgCyan) c.Println("Prints cyan text") c.DisableColor() c.Println("This is printed without any color") c.EnableColor() c.Println("This prints again cyan...") ``` ## Todo * Save/Return previous values * Evaluate fmt.Formatter interface ## Credits * [Fatih Arslan](https://github.com/fatih) * Windows support via @mattn: [colorable](https://github.com/mattn/go-colorable) ## License The MIT License (MIT) - see [`LICENSE.md`](https://github.com/fatih/color/blob/master/LICENSE.md) for more details color-1.1.0/color.go000066400000000000000000000261611277414061200143060ustar00rootroot00000000000000package color import ( "fmt" "os" "strconv" "strings" "github.com/mattn/go-colorable" "github.com/mattn/go-isatty" ) // NoColor defines if the output is colorized or not. It's dynamically set to // false or true based on the stdout's file descriptor referring to a terminal // or not. This is a global option and affects all colors. For more control // over each color block use the methods DisableColor() individually. var NoColor = !isatty.IsTerminal(os.Stdout.Fd()) // Color defines a custom color object which is defined by SGR parameters. type Color struct { params []Attribute noColor *bool } // Attribute defines a single SGR Code type Attribute int const escape = "\x1b" // Base attributes const ( Reset Attribute = iota Bold Faint Italic Underline BlinkSlow BlinkRapid ReverseVideo Concealed CrossedOut ) // Foreground text colors const ( FgBlack Attribute = iota + 30 FgRed FgGreen FgYellow FgBlue FgMagenta FgCyan FgWhite ) // Foreground Hi-Intensity text colors const ( FgHiBlack Attribute = iota + 90 FgHiRed FgHiGreen FgHiYellow FgHiBlue FgHiMagenta FgHiCyan FgHiWhite ) // Background text colors const ( BgBlack Attribute = iota + 40 BgRed BgGreen BgYellow BgBlue BgMagenta BgCyan BgWhite ) // Background Hi-Intensity text colors const ( BgHiBlack Attribute = iota + 100 BgHiRed BgHiGreen BgHiYellow BgHiBlue BgHiMagenta BgHiCyan BgHiWhite ) // New returns a newly created color object. func New(value ...Attribute) *Color { c := &Color{params: make([]Attribute, 0)} c.Add(value...) return c } // Set sets the given parameters immediately. It will change the color of // output with the given SGR parameters until color.Unset() is called. func Set(p ...Attribute) *Color { c := New(p...) c.Set() return c } // Unset resets all escape attributes and clears the output. Usually should // be called after Set(). func Unset() { if NoColor { return } fmt.Fprintf(Output, "%s[%dm", escape, Reset) } // Set sets the SGR sequence. func (c *Color) Set() *Color { if c.isNoColorSet() { return c } fmt.Fprintf(Output, c.format()) return c } func (c *Color) unset() { if c.isNoColorSet() { return } Unset() } // Add is used to chain SGR parameters. Use as many as parameters to combine // and create custom color objects. Example: Add(color.FgRed, color.Underline). func (c *Color) Add(value ...Attribute) *Color { c.params = append(c.params, value...) return c } func (c *Color) prepend(value Attribute) { c.params = append(c.params, 0) copy(c.params[1:], c.params[0:]) c.params[0] = value } // Output defines the standard output of the print functions. By default // os.Stdout is used. var Output = colorable.NewColorableStdout() // Print formats using the default formats for its operands and writes to // standard output. Spaces are added between operands when neither is a // string. It returns the number of bytes written and any write error // encountered. This is the standard fmt.Print() method wrapped with the given // color. func (c *Color) Print(a ...interface{}) (n int, err error) { c.Set() defer c.unset() return fmt.Fprint(Output, a...) } // Printf formats according to a format specifier and writes to standard output. // It returns the number of bytes written and any write error encountered. // This is the standard fmt.Printf() method wrapped with the given color. func (c *Color) Printf(format string, a ...interface{}) (n int, err error) { c.Set() defer c.unset() return fmt.Fprintf(Output, format, a...) } // Println formats using the default formats for its operands and writes to // standard output. Spaces are always added between operands and a newline is // appended. It returns the number of bytes written and any write error // encountered. This is the standard fmt.Print() method wrapped with the given // color. func (c *Color) Println(a ...interface{}) (n int, err error) { c.Set() defer c.unset() return fmt.Fprintln(Output, a...) } // PrintFunc returns a new function that prints the passed arguments as // colorized with color.Print(). func (c *Color) PrintFunc() func(a ...interface{}) { return func(a ...interface{}) { c.Print(a...) } } // PrintfFunc returns a new function that prints the passed arguments as // colorized with color.Printf(). func (c *Color) PrintfFunc() func(format string, a ...interface{}) { return func(format string, a ...interface{}) { c.Printf(format, a...) } } // PrintlnFunc returns a new function that prints the passed arguments as // colorized with color.Println(). func (c *Color) PrintlnFunc() func(a ...interface{}) { return func(a ...interface{}) { c.Println(a...) } } // SprintFunc returns a new function that returns colorized strings for the // given arguments with fmt.Sprint(). Useful to put into or mix into other // string. Windows users should use this in conjuction with color.Output, example: // // put := New(FgYellow).SprintFunc() // fmt.Fprintf(color.Output, "This is a %s", put("warning")) func (c *Color) SprintFunc() func(a ...interface{}) string { return func(a ...interface{}) string { return c.wrap(fmt.Sprint(a...)) } } // SprintfFunc returns a new function that returns colorized strings for the // given arguments with fmt.Sprintf(). Useful to put into or mix into other // string. Windows users should use this in conjuction with color.Output. func (c *Color) SprintfFunc() func(format string, a ...interface{}) string { return func(format string, a ...interface{}) string { return c.wrap(fmt.Sprintf(format, a...)) } } // SprintlnFunc returns a new function that returns colorized strings for the // given arguments with fmt.Sprintln(). Useful to put into or mix into other // string. Windows users should use this in conjuction with color.Output. func (c *Color) SprintlnFunc() func(a ...interface{}) string { return func(a ...interface{}) string { return c.wrap(fmt.Sprintln(a...)) } } // sequence returns a formated SGR sequence to be plugged into a "\x1b[...m" // an example output might be: "1;36" -> bold cyan func (c *Color) sequence() string { format := make([]string, len(c.params)) for i, v := range c.params { format[i] = strconv.Itoa(int(v)) } return strings.Join(format, ";") } // wrap wraps the s string with the colors attributes. The string is ready to // be printed. func (c *Color) wrap(s string) string { if c.isNoColorSet() { return s } return c.format() + s + c.unformat() } func (c *Color) format() string { return fmt.Sprintf("%s[%sm", escape, c.sequence()) } func (c *Color) unformat() string { return fmt.Sprintf("%s[%dm", escape, Reset) } // DisableColor disables the color output. Useful to not change any existing // code and still being able to output. Can be used for flags like // "--no-color". To enable back use EnableColor() method. func (c *Color) DisableColor() { c.noColor = boolPtr(true) } // EnableColor enables the color output. Use it in conjuction with // DisableColor(). Otherwise this method has no side effects. func (c *Color) EnableColor() { c.noColor = boolPtr(false) } func (c *Color) isNoColorSet() bool { // check first if we have user setted action if c.noColor != nil { return *c.noColor } // if not return the global option, which is disabled by default return NoColor } // Equals returns a boolean value indicating whether two colors are equal. func (c *Color) Equals(c2 *Color) bool { if len(c.params) != len(c2.params) { return false } for _, attr := range c.params { if !c2.attrExists(attr) { return false } } return true } func (c *Color) attrExists(a Attribute) bool { for _, attr := range c.params { if attr == a { return true } } return false } func boolPtr(v bool) *bool { return &v } // Black is an convenient helper function to print with black foreground. A // newline is appended to format by default. func Black(format string, a ...interface{}) { printColor(format, FgBlack, a...) } // Red is an convenient helper function to print with red foreground. A // newline is appended to format by default. func Red(format string, a ...interface{}) { printColor(format, FgRed, a...) } // Green is an convenient helper function to print with green foreground. A // newline is appended to format by default. func Green(format string, a ...interface{}) { printColor(format, FgGreen, a...) } // Yellow is an convenient helper function to print with yellow foreground. // A newline is appended to format by default. func Yellow(format string, a ...interface{}) { printColor(format, FgYellow, a...) } // Blue is an convenient helper function to print with blue foreground. A // newline is appended to format by default. func Blue(format string, a ...interface{}) { printColor(format, FgBlue, a...) } // Magenta is an convenient helper function to print with magenta foreground. // A newline is appended to format by default. func Magenta(format string, a ...interface{}) { printColor(format, FgMagenta, a...) } // Cyan is an convenient helper function to print with cyan foreground. A // newline is appended to format by default. func Cyan(format string, a ...interface{}) { printColor(format, FgCyan, a...) } // White is an convenient helper function to print with white foreground. A // newline is appended to format by default. func White(format string, a ...interface{}) { printColor(format, FgWhite, a...) } func printColor(format string, p Attribute, a ...interface{}) { if len(a) == 0 { a = append(a, format) format = "%s" } if !strings.HasSuffix(format, "\n") { format += "\n" } c := &Color{params: []Attribute{p}} c.Printf(format, a...) } func printString(format string, p Attribute, a ...interface{}) string { if len(a) == 0 { a = append(a, format) format = "%s" } return New(p).SprintfFunc()(format, a...) } // BlackString is an convenient helper function to return a string with black // foreground. func BlackString(format string, a ...interface{}) string { return printString(format, FgBlack, a...) } // RedString is an convenient helper function to return a string with red // foreground. func RedString(format string, a ...interface{}) string { return printString(format, FgRed, a...) } // GreenString is an convenient helper function to return a string with green // foreground. func GreenString(format string, a ...interface{}) string { return printString(format, FgGreen, a...) } // YellowString is an convenient helper function to return a string with yellow // foreground. func YellowString(format string, a ...interface{}) string { return printString(format, FgYellow, a...) } // BlueString is an convenient helper function to return a string with blue // foreground. func BlueString(format string, a ...interface{}) string { return printString(format, FgBlue, a...) } // MagentaString is an convenient helper function to return a string with magenta // foreground. func MagentaString(format string, a ...interface{}) string { return printString(format, FgMagenta, a...) } // CyanString is an convenient helper function to return a string with cyan // foreground. func CyanString(format string, a ...interface{}) string { return printString(format, FgCyan, a...) } // WhiteString is an convenient helper function to return a string with white // foreground. func WhiteString(format string, a ...interface{}) string { return printString(format, FgWhite, a...) } color-1.1.0/color_test.go000066400000000000000000000146161277414061200153470ustar00rootroot00000000000000package color import ( "bytes" "fmt" "testing" "github.com/mattn/go-colorable" ) // Testing colors is kinda different. First we test for given colors and their // escaped formatted results. Next we create some visual tests to be tested. // Each visual test includes the color name to be compared. func TestColor(t *testing.T) { rb := new(bytes.Buffer) Output = rb NoColor = false testColors := []struct { text string code Attribute }{ {text: "black", code: FgBlack}, {text: "red", code: FgRed}, {text: "green", code: FgGreen}, {text: "yellow", code: FgYellow}, {text: "blue", code: FgBlue}, {text: "magent", code: FgMagenta}, {text: "cyan", code: FgCyan}, {text: "white", code: FgWhite}, {text: "hblack", code: FgHiBlack}, {text: "hred", code: FgHiRed}, {text: "hgreen", code: FgHiGreen}, {text: "hyellow", code: FgHiYellow}, {text: "hblue", code: FgHiBlue}, {text: "hmagent", code: FgHiMagenta}, {text: "hcyan", code: FgHiCyan}, {text: "hwhite", code: FgHiWhite}, } for _, c := range testColors { New(c.code).Print(c.text) line, _ := rb.ReadString('\n') scannedLine := fmt.Sprintf("%q", line) colored := fmt.Sprintf("\x1b[%dm%s\x1b[0m", c.code, c.text) escapedForm := fmt.Sprintf("%q", colored) fmt.Printf("%s\t: %s\n", c.text, line) if scannedLine != escapedForm { t.Errorf("Expecting %s, got '%s'\n", escapedForm, scannedLine) } } } func TestColorEquals(t *testing.T) { fgblack1 := New(FgBlack) fgblack2 := New(FgBlack) bgblack := New(BgBlack) fgbgblack := New(FgBlack, BgBlack) fgblackbgred := New(FgBlack, BgRed) fgred := New(FgRed) bgred := New(BgRed) if !fgblack1.Equals(fgblack2) { t.Error("Two black colors are not equal") } if fgblack1.Equals(bgblack) { t.Error("Fg and bg black colors are equal") } if fgblack1.Equals(fgbgblack) { t.Error("Fg black equals fg/bg black color") } if fgblack1.Equals(fgred) { t.Error("Fg black equals Fg red") } if fgblack1.Equals(bgred) { t.Error("Fg black equals Bg red") } if fgblack1.Equals(fgblackbgred) { t.Error("Fg black equals fg black bg red") } } func TestNoColor(t *testing.T) { rb := new(bytes.Buffer) Output = rb testColors := []struct { text string code Attribute }{ {text: "black", code: FgBlack}, {text: "red", code: FgRed}, {text: "green", code: FgGreen}, {text: "yellow", code: FgYellow}, {text: "blue", code: FgBlue}, {text: "magent", code: FgMagenta}, {text: "cyan", code: FgCyan}, {text: "white", code: FgWhite}, {text: "hblack", code: FgHiBlack}, {text: "hred", code: FgHiRed}, {text: "hgreen", code: FgHiGreen}, {text: "hyellow", code: FgHiYellow}, {text: "hblue", code: FgHiBlue}, {text: "hmagent", code: FgHiMagenta}, {text: "hcyan", code: FgHiCyan}, {text: "hwhite", code: FgHiWhite}, } for _, c := range testColors { p := New(c.code) p.DisableColor() p.Print(c.text) line, _ := rb.ReadString('\n') if line != c.text { t.Errorf("Expecting %s, got '%s'\n", c.text, line) } } // global check NoColor = true defer func() { NoColor = false }() for _, c := range testColors { p := New(c.code) p.Print(c.text) line, _ := rb.ReadString('\n') if line != c.text { t.Errorf("Expecting %s, got '%s'\n", c.text, line) } } } func TestColorVisual(t *testing.T) { // First Visual Test Output = colorable.NewColorableStdout() New(FgRed).Printf("red\t") New(BgRed).Print(" ") New(FgRed, Bold).Println(" red") New(FgGreen).Printf("green\t") New(BgGreen).Print(" ") New(FgGreen, Bold).Println(" green") New(FgYellow).Printf("yellow\t") New(BgYellow).Print(" ") New(FgYellow, Bold).Println(" yellow") New(FgBlue).Printf("blue\t") New(BgBlue).Print(" ") New(FgBlue, Bold).Println(" blue") New(FgMagenta).Printf("magenta\t") New(BgMagenta).Print(" ") New(FgMagenta, Bold).Println(" magenta") New(FgCyan).Printf("cyan\t") New(BgCyan).Print(" ") New(FgCyan, Bold).Println(" cyan") New(FgWhite).Printf("white\t") New(BgWhite).Print(" ") New(FgWhite, Bold).Println(" white") fmt.Println("") // Second Visual test Black("black") Red("red") Green("green") Yellow("yellow") Blue("blue") Magenta("magenta") Cyan("cyan") White("white") // Third visual test fmt.Println() Set(FgBlue) fmt.Println("is this blue?") Unset() Set(FgMagenta) fmt.Println("and this magenta?") Unset() // Fourth Visual test fmt.Println() blue := New(FgBlue).PrintlnFunc() blue("blue text with custom print func") red := New(FgRed).PrintfFunc() red("red text with a printf func: %d\n", 123) put := New(FgYellow).SprintFunc() warn := New(FgRed).SprintFunc() fmt.Fprintf(Output, "this is a %s and this is %s.\n", put("warning"), warn("error")) info := New(FgWhite, BgGreen).SprintFunc() fmt.Fprintf(Output, "this %s rocks!\n", info("package")) // Fifth Visual Test fmt.Println() fmt.Fprintln(Output, BlackString("black")) fmt.Fprintln(Output, RedString("red")) fmt.Fprintln(Output, GreenString("green")) fmt.Fprintln(Output, YellowString("yellow")) fmt.Fprintln(Output, BlueString("blue")) fmt.Fprintln(Output, MagentaString("magenta")) fmt.Fprintln(Output, CyanString("cyan")) fmt.Fprintln(Output, WhiteString("white")) } func TestNoFormat(t *testing.T) { fmt.Printf("%s %%s = ", BlackString("Black")) Black("%s") fmt.Printf("%s %%s = ", RedString("Red")) Red("%s") fmt.Printf("%s %%s = ", GreenString("Green")) Green("%s") fmt.Printf("%s %%s = ", YellowString("Yellow")) Yellow("%s") fmt.Printf("%s %%s = ", BlueString("Blue")) Blue("%s") fmt.Printf("%s %%s = ", MagentaString("Magenta")) Magenta("%s") fmt.Printf("%s %%s = ", CyanString("Cyan")) Cyan("%s") fmt.Printf("%s %%s = ", WhiteString("White")) White("%s") } func TestNoFormatString(t *testing.T) { tests := []struct { f func(string, ...interface{}) string format string args []interface{} want string }{ {BlackString, "%s", nil, "\x1b[30m%s\x1b[0m"}, {RedString, "%s", nil, "\x1b[31m%s\x1b[0m"}, {GreenString, "%s", nil, "\x1b[32m%s\x1b[0m"}, {YellowString, "%s", nil, "\x1b[33m%s\x1b[0m"}, {BlueString, "%s", nil, "\x1b[34m%s\x1b[0m"}, {MagentaString, "%s", nil, "\x1b[35m%s\x1b[0m"}, {CyanString, "%s", nil, "\x1b[36m%s\x1b[0m"}, {WhiteString, "%s", nil, "\x1b[37m%s\x1b[0m"}, } for i, test := range tests { s := fmt.Sprintf("%s", test.f(test.format, test.args...)) if s != test.want { t.Errorf("[%d] want: %q, got: %q", i, test.want, s) } } } color-1.1.0/doc.go000066400000000000000000000072321277414061200137330ustar00rootroot00000000000000/* Package color is an ANSI color package to output colorized or SGR defined output to the standard output. The API can be used in several way, pick one that suits you. Use simple and default helper functions with predefined foreground colors: color.Cyan("Prints text in cyan.") // a newline will be appended automatically color.Blue("Prints %s in blue.", "text") // More default foreground colors.. color.Red("We have red") color.Yellow("Yellow color too!") color.Magenta("And many others ..") However there are times where custom color mixes are required. Below are some examples to create custom color objects and use the print functions of each separate color object. // Create a new color object c := color.New(color.FgCyan).Add(color.Underline) c.Println("Prints cyan text with an underline.") // Or just add them to New() d := color.New(color.FgCyan, color.Bold) d.Printf("This prints bold cyan %s\n", "too!.") // Mix up foreground and background colors, create new mixes! red := color.New(color.FgRed) boldRed := red.Add(color.Bold) boldRed.Println("This will print text in bold red.") whiteBackground := red.Add(color.BgWhite) whiteBackground.Println("Red text with White background.") You can create PrintXxx functions to simplify even more: // Create a custom print function for convenient red := color.New(color.FgRed).PrintfFunc() red("warning") red("error: %s", err) // Mix up multiple attributes notice := color.New(color.Bold, color.FgGreen).PrintlnFunc() notice("don't forget this...") Or create SprintXxx functions to mix strings with other non-colorized strings: yellow := New(FgYellow).SprintFunc() red := New(FgRed).SprintFunc() fmt.Printf("this is a %s and this is %s.\n", yellow("warning"), red("error")) info := New(FgWhite, BgGreen).SprintFunc() fmt.Printf("this %s rocks!\n", info("package")) Windows support is enabled by default. All Print functions works as intended. However only for color.SprintXXX functions, user should use fmt.FprintXXX and set the output to color.Output: fmt.Fprintf(color.Output, "Windows support: %s", color.GreenString("PASS")) info := New(FgWhite, BgGreen).SprintFunc() fmt.Fprintf(color.Output, "this %s rocks!\n", info("package")) Using with existing code is possible. Just use the Set() method to set the standard output to the given parameters. That way a rewrite of an existing code is not required. // Use handy standard colors. color.Set(color.FgYellow) fmt.Println("Existing text will be now in Yellow") fmt.Printf("This one %s\n", "too") color.Unset() // don't forget to unset // You can mix up parameters color.Set(color.FgMagenta, color.Bold) defer color.Unset() // use it in your function fmt.Println("All text will be now bold magenta.") There might be a case where you want to disable color output (for example to pipe the standard output of your app to somewhere else). `Color` has support to disable colors both globally and for single color definition. For example suppose you have a CLI app and a `--no-color` bool flag. You can easily disable the color output with: var flagNoColor = flag.Bool("no-color", false, "Disable color output") if *flagNoColor { color.NoColor = true // disables colorized output } It also has support for single color definitions (local). You can disable/enable color output on the fly: c := color.New(color.FgCyan) c.Println("Prints cyan text") c.DisableColor() c.Println("This is printed without any color") c.EnableColor() c.Println("This prints again cyan...") */ package color