Golang go-colortext.ResetColor函数代码示例

func (tokens LogTokens) Print() {
	defer color.ResetColor()

	var defColor color.Color = color.White
	var defBright bool = true

	for _, token := range tokens {
		if token.Type >= TOKEN_DEBUG {
			defColor, defBright, _ = token.Type.getFgColor()
		}
	}

	for _, token := range tokens {
		fg, bright, specific := token.Type.getFgColor()
		if !specific {
			fg = defColor
			bright = defBright
		}

		color.Foreground(fg, bright)
		fmt.Print(token.Text)
	}

	fmt.Print("\n")
}

func init() {
	defer ct.ResetColor()
	//	WriteOutLevel(OUT_LEVEL_WARNING)
	//	WriteOut("#####################################\n  Chandra Application")
	//	WriteOut("\n#####################################\n")
	//	WriteOutLevel(OUT_LEVEL_RESET)
}

// outputColorStack is use when -logcolor is enabled.
// colored stack printing is allowed to be inefficient because it's a local development feature.
func outputColorStack(stacks []byte, s severity) {
	r := bytes.NewReader(stacks)
	scanner := bufio.NewScanner(r)
	for scanner.Scan() {
		l := scanner.Bytes()
		if len(l) > 0 && l[0] == "\t"[0] {
			addroffset := bytes.LastIndex(l, []byte(" "))
			linumoffset := bytes.LastIndex(l, []byte(":"))
			if addroffset == -1 || linumoffset == -1 {
				os.Stderr.Write(l)
				goto eol
			}
			srcpath := l[0:linumoffset]
			hlstart := 0
			hlstacksrc.Lock()
			if hlstacksrc.v != nil {
				for _, v := range hlstacksrc.v {
					offs := bytes.Index(srcpath, v)
					if offs > hlstart {
						hlstart = offs
					}
				}
			}
			hlstacksrc.Unlock()
			if hlstart > 0 {
				os.Stderr.Write(srcpath[:hlstart])
				ct.Foreground(ct.Blue, true)
				os.Stderr.Write(srcpath[hlstart:])
				ct.ResetColor()
			} else {
				os.Stderr.Write(srcpath)
			}
			os.Stderr.WriteString(":")
			printColor(s)
			os.Stderr.Write(l[linumoffset+1 : addroffset])
			ct.ResetColor()
			os.Stderr.Write(l[addroffset:])
		} else {
			os.Stderr.Write(l)
		}
	eol:
		os.Stderr.WriteString("\n")
	}
	if err := scanner.Err(); err != nil {
		fmt.Fprintln(os.Stderr, "reading standard input:", err)
	}
}

func WriteOut(s string, ars ...interface{}) {
	if len(ars) > 0 {
		fmt.Printf(s, ars)
	} else {
		fmt.Print(s)
	}
	ct.ResetColor()
}

// Write out a single coloured line
func (of *OutletFactory) WriteLine(left, right string, leftC, rightC ct.Color, isError bool) {
	of.Lock()
	defer of.Unlock()

	ct.ChangeColor(leftC, true, ct.None, false)
	formatter := fmt.Sprintf("%%-%ds | ", of.Padding)
	fmt.Printf(formatter, left)

	if isError {
		ct.ChangeColor(ct.Red, true, ct.None, true)
	} else {
		ct.ResetColor()
	}
	fmt.Println(right)
	if isError {
		ct.ResetColor()
	}
}

func (e *BigcommerceAppLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Printf("%s  ", e.SyslogTime.Format("2006-01-02 15:04:05"))
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("bigcommerce-app  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%s-%d  ", e.LogLevel, e.StoreContext.StoreId)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Content)
}

func (e *GenericLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("generic  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%s  ", e.Name)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Content)
}

func (e *ProcessLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("process  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%s-%d  ", e.Name, e.ProcessId)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Content)
}

func (e *PhpStackTraceLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)
	fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
	ct.ChangeColor(ct.Yellow, false, ct.None, false)
	fmt.Print("php-stack-trace  ")
	ct.ChangeColor(ct.Cyan, false, ct.None, false)
	fmt.Printf("%d-%s-%d  ", e.Number, e.File, e.Line)
	ct.ResetColor()
	fmt.Printf("%s\n", e.Method)
}

func WriteOutLevel(l string) {
	switch l {
	case OUT_LEVEL_WARNING:
		ct.ChangeColor(ct.Yellow, true, ct.None, false)
	case OUT_LEVEL_ERROR:
		ct.ChangeColor(ct.Red, true, ct.None, false)
	case OUT_LEVEL_INFO:
		ct.ChangeColor(ct.Cyan, true, ct.None, false)
	default:
		ct.ResetColor()
	}
}

func print(timeFormat string, le *logEntry) {
	var level string
	switch le.level {
	case Info:
		level = "INFO    "
		ct.Foreground(ct.Cyan, false)
	case Warning:
		level = "WARNING "
		ct.Foreground(ct.Yellow, false)
	case Error:
		level = "ERROR   "
		ct.Foreground(ct.Red, false)
	case Critical:
		level = "CRITICAL"
		ct.ChangeColor(ct.Black, false, ct.Red, false)
	case Fatal:
		level = "FATAL   "
		ct.ResetColor()
	}
	fmt.Println(le.time.Format(timeFormat), level, le.message)
	ct.ResetColor()
}

func (e *NginxErrorLogEvent) PrintLine(index int) {
	fmt.Printf("[%d]  ", index)

	if e.LogLevel == "error" {
		fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
		ct.ChangeColor(ct.Yellow, false, ct.Red, false)
		fmt.Print("nginx-error  ")
		ct.ChangeColor(ct.Cyan, false, ct.Red, false)
		fmt.Printf("%s  ", e.LogLevel)
		ct.ChangeColor(ct.None, false, ct.Red, false)
		fmt.Printf("%s %s\n", e.Request.Uri, e.Content)
		ct.ResetColor()
	} else {
		fmt.Print(e.SyslogTime.Format("2006-01-02 15:04:05") + "  ")
		ct.ChangeColor(ct.Yellow, false, ct.None, false)
		fmt.Print("nginx-error  ")
		ct.ChangeColor(ct.Cyan, false, ct.None, false)
		fmt.Printf("%s  ", e.LogLevel)
		ct.ResetColor()
		fmt.Printf("%s %s\n", e.Request.Uri, e.Content)
	}
}

func (cl *coloredLogger) ScenarioStart(scenarioHeading string) {
	msg := formatScenario(scenarioHeading)
	Log.Info(msg)

	indentedText := indent(msg, scenarioIndentation)
	if level == logging.INFO {
		cl.headingText.WriteString(indentedText + spaces(4))
		cl.writeToConsole(cl.headingText.String(), ct.None, false)
	} else {
		ct.Foreground(ct.Yellow, false)
		ConsoleWrite(indentedText)
		ct.ResetColor()
	}
}

// A simple function to print message with colors.
func ColoredPrint(thecolor color.Color, bold bool, values ...interface{}) {

	// change the color of the terminal
	color.ChangeColor(
		thecolor,
		bold,
		None,
		false,
	)

	// print
	fmt.Print(values...)

	// reset the color
	color.ResetColor()
}

func TestGetConsoleColor(t *testing.T) {
	for b := uint32(0); b < 6; b++ {
		for g := uint32(0); g < 6; g++ {
			for r := uint32(0); r < 6; r++ {
				m, l, h, j, k := GetConsoleColor(r*0x33/4, g*0x33/4, b*0x33/4)
				ct.ChangeColor(l, h, j, k)
				c := clist64[m : m+1]
				c = c + c + c + c
				if k {
					fmt.Printf("%s%x", c, (j-1)<<1)
				} else {
					fmt.Printf("%s%x", c, (j - 1))
				}
				ct.ResetColor()
				fmt.Printf("#%02x%02x%02x ", r*0x33, g*0x33, b*0x33)
			}
			fmt.Print("\n")
		}
	}
}