func init() { errCol = ansi.ColorFunc("white+b:red") warnCol = ansi.ColorFunc("208+b") infoCol = ansi.ColorFunc("white+b") debugCol = ansi.ColorFunc("white") bold = ansi.ColorFunc("white+b") }
// RemoveFormat removes the current format func RemoveFormat() { LInfo = "info" LWarn = "warn" LErr = "error" LStart = "start" LDone = "done" STime = ansi.ColorFunc("") SFail = ansi.ColorFunc("") SKey = ansi.ColorFunc("") SVal = ansi.ColorFunc("") }
// Status implements the `got status` command. func Status(c *cli.Context) { // Open the database db := util.OpenDB() defer db.Close() // Colored output yellow := ansi.ColorFunc("yellow+h:black") green := ansi.ColorFunc("green+h:black") red := ansi.ColorFunc("red+h:black") // Perform operations in a read-only lock err := db.View(func(tx *bolt.Tx) error { // Get the current commit sha info := tx.Bucket(util.INFO) objects := tx.Bucket(util.OBJECTS) current := info.Get(util.CURRENT) // Find the differences between the working directory and the tree of the current commit. differences := []Difference{} if current != nil { // Load commit object commit := types.DeserializeCommitObject(objects.Get(current)) util.DebugLog("Comparing working directory to commit '" + commit.Message + "'.") differences = TreeDiff(objects, commit.Tree, ".") } else { // Compare directory to the empty hash util.DebugLog("Comparing working directory to empty tree.") differences = TreeDiff(objects, types.EMPTY, ".") } // Print out the found differences for _, difference := range differences { line := fmt.Sprintf("%s %s", difference.Type, difference.FilePath) if difference.Type == "A" { fmt.Println(green(line)) } if difference.Type == "R" { fmt.Println(red(line)) } if difference.Type == "M" { fmt.Println(yellow(line)) } } return nil }) if err != nil { log.Fatal("Error reading from the database.") } }
func AssertJSONBody(tb testing.TB, exp, act interface{}) { red := ansi.ColorCode("red+h:black") green := ansi.ColorCode("green+h:black") yellow := ansi.ColorFunc("yellow+h") reset := ansi.ColorCode("reset") var actBuf bytes.Buffer err := json.Indent(&actBuf, []byte(act.(string)), "", " ") if err != nil { fmt.Println(red, "Invalid json: ", act, reset) } act = string(actBuf.Bytes()) var expBuf bytes.Buffer err = json.Indent(&expBuf, []byte(exp.(string)), "", " ") if err != nil { fmt.Println(red, "Invalid json: ", exp, reset) } exp = string(expBuf.Bytes()) if !reflect.DeepEqual(exp, act) { _, file, line, _ := runtime.Caller(1) fmt.Println(yellow(fmt.Sprintf("%s:%d", filepath.Base(file), line))) fmt.Println(green, "Expected: ", exp, reset) fmt.Println(red, " Got: ", act, reset) tb.FailNow() } }
// Prints the information for one commit in the log, including ascii graph on left side of commits if // -graph arg is true. func printCommit(node LogNode, db datas.Database) (err error) { lineno := 0 doColor := func(s string) string { return s } if useColor { doColor = ansi.ColorFunc("red+h") } fmt.Printf("%s%s\n", genGraph(node, lineno), doColor(node.commit.Hash().String())) parents := commitRefsFromSet(node.commit.Get(datas.ParentsField).(types.Set)) lineno++ if len(parents) > 1 { pstrings := []string{} for _, cr := range parents { pstrings = append(pstrings, cr.TargetHash().String()) } fmt.Printf("%sMerge: %s\n", genGraph(node, lineno), strings.Join(pstrings, " ")) } else if len(parents) == 1 { fmt.Printf("%sParent: %s\n", genGraph(node, lineno), parents[0].TargetHash().String()) } else { fmt.Printf("%sParent: None\n", genGraph(node, lineno)) } if *maxLines != 0 { var n int if *showValue { n, err = writeCommitLines(node, *maxLines, lineno, os.Stdout) } else { n, err = writeDiffLines(node, db, *maxLines, lineno, os.Stdout) } lineno += n } return }
func (self *Context) PrintUsage() { if self.App.Usage != "" { self.Print(self.App.Usage) return } boldUnderline := ansi.ColorFunc("white+bu") self.Print("\n%s", boldUnderline("COMMANDS")) maxLength1 := getMaxLength(self.App.Commands) maxLength2 := getMaxLength(self.App.Flags) + 2 maxLength := maxLength1 if maxLength2 > maxLength1 { maxLength = maxLength2 } for _, k := range self.App.CommandKeys { command := padRight(k, " ", maxLength+3) self.Print(command + self.App.Commands[k]) } if len(self.App.FlagKeys) > 0 { self.Print("\n%s", boldUnderline("FLAGS")) for _, k := range self.App.FlagKeys { flag := padRight("--"+k, " ", maxLength+3) desc := self.App.Flags[k] if self.App.FlagDefaults[k] != "" { desc += " (default: " + self.App.FlagDefaults[k] + ")" } self.Print(flag + desc) } } }
func handleMessage(msg wray.Message) { redColor := ansi.ColorFunc("red+h") capColor := ansi.ColorFunc("yellow") infoColor := ansi.ColorFunc("white") s, err := strconv.Unquote(msg.Data) if err != nil { fmt.Println("Error: ", err) } var m logMessage err = json.Unmarshal([]byte(s), &m) if err != nil { fmt.Println("Error:", err) } var level string var colorFunc func(string) string switch m.Severity { case 0: level = "TRACE" colorFunc = infoColor case 1: level = "DEBUG" colorFunc = infoColor case 2: level = "INFO" colorFunc = infoColor case 3: level = "WARN" colorFunc = capColor case 4: level = "ERROR" colorFunc = redColor case 5: level = "IMPORTANT" colorFunc = redColor case 6: level = "FATAL" colorFunc = redColor } fmt.Println(colorFunc(fmt.Sprintf("%s [%s] - %s", m.Time, level, m.Message))) }
func cmdList(c *cli.Context) error { conf, err := config.Open(c.GlobalString("config")) if err != nil { Logger.Fatalf("Cannot load configuration: %v", err) return nil } // ansi coloring greenColorize := func(input string) string { return input } redColorize := func(input string) string { return input } yellowColorize := func(input string) string { return input } if terminal.IsTerminal(int(os.Stdout.Fd())) { greenColorize = ansi.ColorFunc("green+b+h") redColorize = ansi.ColorFunc("red") yellowColorize = ansi.ColorFunc("yellow") } fmt.Printf("Listing entries\n\n") for _, host := range conf.Hosts.SortedList() { options := host.Options() options.Remove("User") options.Remove("Port") host.ApplyDefaults(&conf.Defaults) fmt.Printf(" %s -> %s\n", greenColorize(host.Name()), host.Prototype()) if len(options) > 0 { fmt.Printf(" %s %s\n", yellowColorize("[custom options]"), strings.Join(options.ToStringList(), " ")) } fmt.Println() } generalOptions := conf.Defaults.Options() if len(generalOptions) > 0 { fmt.Println(greenColorize(" (*) General options:")) for _, opt := range conf.Defaults.Options() { fmt.Printf(" %s: %s\n", redColorize(opt.Name), opt.Value) } fmt.Println() } return nil }
func init() { flag.Usage = func() { fmt.Printf("Usage: ./colorize -color 'red:green' -alt=false\n") flag.PrintDefaults() } flag.Parse() if *colorFlag != "" { color = ansi.ColorFunc(*colorFlag) } }
func (m *Map) String() string { var b bytes.Buffer // Nice colors for debugging. r := ansi.ColorFunc("red") g := ansi.ColorFunc("green") for y := 0; y < m.size; y++ { for x := 0; x < m.size; x++ { v := m.get(x, y) if v > 0 { fmt.Fprint(&b, r(fmt.Sprintf("%.2f ", v))) } else { fmt.Fprint(&b, g(fmt.Sprintf("%.2f ", v))) } } fmt.Fprint(&b, "\n") } return b.String() }
func getColorFunction(code string) ColorizeFunc { var ( colorFunc ColorizeFunc ok bool ) if colorFunc, ok = colorFuncMap[code]; ok { return colorFunc } colorFunc = ColorizeFunc(ansi.ColorFunc(code)) colorFuncMap[code] = colorFunc return colorFunc }
func Log(c *cli.Context) { db := util.OpenDB() defer db.Close() yellow := ansi.ColorFunc("yellow+h:black") // Perform operations in a read-only lock db.View(func(tx *bolt.Tx) error { info := tx.Bucket(util.INFO) objects := tx.Bucket(util.OBJECTS) headsBytes := info.Get(util.HEADS) if headsBytes != nil { queue := types.DeserializeHashes(headsBytes) // TODO: Keep a visited set, so we don't repeat commits for len(queue) > 0 { i := GetNewestCommit(objects, queue) // Get commit and remove it from the priority queue commitSha := queue[i] commit := types.DeserializeCommitObject(objects.Get(commitSha)) queue = append(queue[:i], queue[i+1:]...) fmt.Printf(yellow("commit %s\n"), commitSha) fmt.Printf("Message: %s\n", commit.Message) fmt.Printf("Author: %s\n", commit.Author) fmt.Printf("Date: %s\n", commit.Time) if len(commit.Parents) > 0 { fmt.Printf("Parents: %s\n", commit.Parents) } fmt.Printf("Tree: %s\n", commit.Tree) fmt.Println() // Append parents of this commit to the queue queue = append(queue, commit.Parents...) } return nil } fmt.Println("There are no commits in this repository...") return nil }) }
func init() { ansi.DisableColors(false) cyan = ansi.ColorFunc("cyan") red = ansi.ColorFunc("red+b") yellow = ansi.ColorFunc("yellow+b") redInverse = ansi.ColorFunc("white:red") gray = ansi.ColorFunc("black+h") magenta = ansi.ColorFunc("magenta+h") writer = colorable.NewColorableStdout() }
func AssertEqual(tb testing.TB, exp, act interface{}) { if !reflect.DeepEqual(exp, act) { yellow := ansi.ColorFunc("yellow+h") green := ansi.ColorCode("green+h:black") red := ansi.ColorCode("red+h:black") reset := ansi.ColorCode("reset") _, file, line, _ := runtime.Caller(1) fmt.Println(yellow(fmt.Sprintf("%s:%d", filepath.Base(file), line))) fmt.Println(green, "Expected: ", exp, reset) fmt.Println(red, " Got: ", act, reset) tb.FailNow() } }
func main() { reset := ansi.ColorCode("reset") msg := ansi.Color("red+b", "red+b:white") fmt.Println(msg, reset) msg = ansi.Color("green", "green") fmt.Println(msg, reset) msg = ansi.Color("background white", "black:white") fmt.Println(msg, reset) warn := ansi.ColorFunc("yellow:black") fmt.Println(warn("this is warning!"), reset) lime := ansi.ColorCode("green+h:black") fmt.Println(lime, "Lime message.", reset) }
func (current *CurrentColor) Set(value string) error { if current.color != value { if !strings.Contains(value, ":") { // foreground:background if value == "black" { value += ":white" } else { value += ":black" } } current.color = value current.colorfunc = ansi.ColorFunc(current.color) } return nil }
// Demo demo func Demo() { // colorize a string, slowest method msg := ansi.Color("foo", "red+b:white") fmt.Print(msg) // create a closure to avoid escape code compilation phosphorize := ansi.ColorFunc("green+h:black") msg = phosphorize("Bring back the 80s!") fmt.Print(msg) // cache escape codes and build strings manually, faster than closure lime := ansi.ColorCode("green+h:black") reset := ansi.ColorCode("reset") msg = lime + "Bring back the 80s!" + reset fmt.Print(msg) }
func init() { failMsg = ansi.ColorFunc("red+b") changedMsg = ansi.ColorFunc("yellow") okMsg = ansi.ColorFunc("green") }
// Copyright 2015 Dominique Feyer <*****@*****.**>. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package logger import ( "github.com/dfeyer/flow-debugproxy/config" "bytes" "fmt" "github.com/mgutz/ansi" ) var ( debugize = ansi.ColorFunc("green+h:black") greenize = ansi.ColorFunc("green") redize = ansi.ColorFunc("red") ) // Logger handle log message type Logger struct { Config *config.Config } //Debug output a debug text func (l *Logger) Debug(f string, args ...interface{}) { if l.Config.Debug { fmt.Printf(debugize("[DEBUG] "+f)+"\n", args...) } }
LInfo = ansi.Color("info", "green") // LWarn shows warning messages LWarn = ansi.Color("warn", "yellow") // LErr shows error messages LErr = ansi.Color("error", "red") // LStart shows start messages LStart = ansi.Color("start", "blue+h") // LDone shows done messages LDone = ansi.Color("done", "blue+h") // STime is style for time STime = ansi.ColorFunc("magenta+h") // SFail is style for faillures SFail = ansi.ColorFunc("red+h") // SKey is style for keys SKey = ansi.ColorFunc("cyan") // SVal is style for values SVal = ansi.ColorFunc("white+b") ) func funcName(d int) string { pc, _, _, _ := runtime.Caller(d + 1) return runtime.FuncForPC(pc).Name() }
package main import ( "bytes" "io" "io/ioutil" "os" "path/filepath" "regexp" "strings" "github.com/jessevdk/go-flags" "github.com/mgutz/ansi" ) var styleRed = ansi.ColorFunc("red") var styleRedUnderline = ansi.ColorFunc("red+u") var styleGreen = ansi.ColorFunc("green") var styleGreenUnderline = ansi.ColorFunc("green+u") var styleHeader = ansi.ColorFunc("white+b:black") var styleBold = ansi.ColorFunc("+b") func main() { dir, _ := os.Getwd() exitCode := mainSub(dir, os.Stdout, os.Stdin, os.Args[1:]) if exitCode != 0 { os.Exit(exitCode) } } type options struct {
package main import ( "fmt" "io/ioutil" "os" "strings" "github.com/codegangsta/cli" "github.com/mgutz/ansi" ) var green = ansi.ColorFunc("green") var red = ansi.ColorFunc("red") var yellow = ansi.ColorFunc("yellow") func main() { app := cli.NewApp() app.Name = "ply" app.Usage = "Deployment made simple" app.Flags = []cli.Flag{ cli.StringFlag{ Name: "config, c", Usage: "The path to your ply config", }, cli.StringFlag{ Name: "environment, e", Usage: "The environment to execute the task", }, cli.StringFlag{ Name: "vars, variables",
func (self *Context) FailWithCode(msg string, code int) { error := ansi.ColorFunc("88") self.PrintError("%s", error(msg)) os.Exit(code) }
package gondorcli import ( "fmt" "os" "github.com/mgutz/ansi" ) var successize = ansi.ColorFunc("green+b") var errize = ansi.ColorFunc("red+b") var heyYou = ansi.ColorFunc("yellow+b") func success(s string) { fmt.Fprintf(os.Stderr, "%s %s\n", successize("Success:"), s) } func failure(s string) { fmt.Fprintf(os.Stderr, "%s %s\n", errize("ERROR:"), s) } func fatal(s string) { failure(s) os.Exit(1) }
package client import ( "bufio" "net" "github.com/mgutz/ansi" ) var phosphorize = ansi.ColorFunc("green+h:black") // Client represents a client connected to the chat type Client struct { Conn net.Conn Receiving chan *Message Outgoing chan *Message Name string Input *bufio.Reader } // Message is what is sent by a client type Message struct { Client *Client Content string } // NewClient is a constructor for Client func NewClient(conn net.Conn, onInit chan *Client) *Client { client := Client{ conn, make(chan *Message),
} } duration := time.Since(start) logObjectPopulate(name, duration) }(injectObject.Name, injectObject.Value) } wg.Wait() log.Info("Done!") return nil } var ( microColor = ansi.ColorFunc("cyan") milliColor = ansi.ColorFunc("yellow") secondsColor = ansi.ColorFunc("red") ) func logObjectPopulate(name string, duration time.Duration) { var ( value string unit string colorFunc func(string) string message string ) s := duration.Seconds() ms := duration.Nanoseconds() / 1000000
func (self *Context) ShowUsageWithMessage(m string) { self.PrintIntro() error := ansi.ColorFunc("88") self.PrintError("\n%s", error(m)) self.PrintUsage() }
"github.com/mgutz/str" "github.com/syreclabs/dat" "github.com/syreclabs/dat/sqlx-runner" . "gopkg.in/godo.v2" "gopkg.in/godo.v2/util" ) func mapBytesToString(m map[string]interface{}) { for k, v := range m { if b, ok := v.([]byte); ok { m[k] = string(b) } } } var lightGreen = ansi.ColorFunc("green+h") var cyan = ansi.ColorFunc("cyan") func printMap(m map[string]interface{}) { first := true fmt.Print(lightGreen("{")) for k, v := range m { if !first { fmt.Print(" ") } fmt.Printf("%s=%v", cyan(k), v) first = false } fmt.Print(lightGreen("}")) fmt.Print("\n")
) var ( logToConsol = false // should log to consol logToFile = false // should log to file logDir = "" // directory in which to store logfiles maxDays = -1 // total number of logfiles at any time // if exeeded will delete oldest //log queue logChan = make(chan logItem, 100) logNameChan = make(chan string, 2) killChan = make(chan bool, 1) //colour functions startupColourFunc = ansi.ColorFunc("green+b") fatalColourFunc = ansi.ColorFunc("red+b") generalColourFunc = ansi.ColorFunc("blue+b") warningColourFunc = ansi.ColorFunc("yellow+b") ) // The colour type enumerator const ( startupColour int = iota fatalColour generalColour warningColour ) // Init initialises the srvlog package. if either consoleLog or fileLog // is true it will start the logger in another gorutine ready to log
func (self *Context) Fail(msg string) { error := ansi.ColorFunc("88") self.PrintError("%s", error(msg)) os.Exit(1) }