316 lines
7.6 KiB
Go
316 lines
7.6 KiB
Go
package color
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
/*************************************************************
|
|
* 16 color Style
|
|
*************************************************************/
|
|
|
|
// Style a 16 color style. can add: fg color, bg color, color options
|
|
//
|
|
// Example:
|
|
// color.Style{color.FgGreen}.Print("message")
|
|
type Style []Color
|
|
|
|
// New create a custom style
|
|
//
|
|
// Usage:
|
|
// color.New(color.FgGreen).Print("message")
|
|
// equals to:
|
|
// color.Style{color.FgGreen}.Print("message")
|
|
func New(colors ...Color) Style {
|
|
return colors
|
|
}
|
|
|
|
// Save to global styles map
|
|
func (s Style) Save(name string) {
|
|
AddStyle(name, s)
|
|
}
|
|
|
|
// Add to global styles map
|
|
func (s *Style) Add(cs ...Color) {
|
|
*s = append(*s, cs...)
|
|
}
|
|
|
|
// Render render text
|
|
// Usage:
|
|
// color.New(color.FgGreen).Render("text")
|
|
// color.New(color.FgGreen, color.BgBlack, color.OpBold).Render("text")
|
|
func (s Style) Render(a ...interface{}) string {
|
|
return RenderCode(s.String(), a...)
|
|
}
|
|
|
|
// Renderln render text line.
|
|
// like Println, will add spaces for each argument
|
|
// Usage:
|
|
// color.New(color.FgGreen).Renderln("text", "more")
|
|
// color.New(color.FgGreen, color.BgBlack, color.OpBold).Render("text", "more")
|
|
func (s Style) Renderln(a ...interface{}) string {
|
|
return RenderWithSpaces(s.String(), a...)
|
|
}
|
|
|
|
// Sprint is alias of the 'Render'
|
|
func (s Style) Sprint(a ...interface{}) string {
|
|
return RenderCode(s.String(), a...)
|
|
}
|
|
|
|
// Sprintf format and render message.
|
|
func (s Style) Sprintf(format string, a ...interface{}) string {
|
|
return RenderString(s.String(), fmt.Sprintf(format, a...))
|
|
}
|
|
|
|
// Print render and Print text
|
|
func (s Style) Print(a ...interface{}) {
|
|
doPrintV2(s.String(), fmt.Sprint(a...))
|
|
}
|
|
|
|
// Printf render and print text
|
|
func (s Style) Printf(format string, a ...interface{}) {
|
|
doPrintV2(s.Code(), fmt.Sprintf(format, a...))
|
|
}
|
|
|
|
// Println render and print text line
|
|
func (s Style) Println(a ...interface{}) {
|
|
doPrintlnV2(s.String(), a)
|
|
}
|
|
|
|
// Code convert to code string. returns like "32;45;3"
|
|
func (s Style) Code() string {
|
|
return s.String()
|
|
}
|
|
|
|
// String convert to code string. returns like "32;45;3"
|
|
func (s Style) String() string {
|
|
return Colors2code(s...)
|
|
}
|
|
|
|
// IsEmpty style
|
|
func (s Style) IsEmpty() bool {
|
|
return len(s) == 0
|
|
}
|
|
|
|
/*************************************************************
|
|
* Theme(extended Style)
|
|
*************************************************************/
|
|
|
|
// Theme definition. extends from Style
|
|
type Theme struct {
|
|
// Name theme name
|
|
Name string
|
|
// Style for the theme
|
|
Style
|
|
}
|
|
|
|
// NewTheme instance
|
|
func NewTheme(name string, style Style) *Theme {
|
|
return &Theme{name, style}
|
|
}
|
|
|
|
// Save to themes map
|
|
func (t *Theme) Save() {
|
|
AddTheme(t.Name, t.Style)
|
|
}
|
|
|
|
// Tips use name as title, only apply style for name
|
|
func (t *Theme) Tips(format string, a ...interface{}) {
|
|
// only apply style for name
|
|
t.Print(strings.ToUpper(t.Name) + ": ")
|
|
Printf(format+"\n", a...)
|
|
}
|
|
|
|
// Prompt use name as title, and apply style for message
|
|
func (t *Theme) Prompt(format string, a ...interface{}) {
|
|
title := strings.ToUpper(t.Name) + ":"
|
|
t.Println(title, fmt.Sprintf(format, a...))
|
|
}
|
|
|
|
// Block like Prompt, but will wrap a empty line
|
|
func (t *Theme) Block(format string, a ...interface{}) {
|
|
title := strings.ToUpper(t.Name) + ":\n"
|
|
|
|
t.Println(title, fmt.Sprintf(format, a...))
|
|
}
|
|
|
|
/*************************************************************
|
|
* Theme: internal themes
|
|
*************************************************************/
|
|
|
|
// internal themes(like bootstrap style)
|
|
// Usage:
|
|
// color.Info.Print("message")
|
|
// color.Info.Printf("a %s message", "test")
|
|
// color.Warn.Println("message")
|
|
// color.Error.Println("message")
|
|
var (
|
|
// Info color style
|
|
Info = &Theme{"info", Style{OpReset, FgGreen}}
|
|
// Note color style
|
|
Note = &Theme{"note", Style{OpBold, FgLightCyan}}
|
|
// Warn color style
|
|
Warn = &Theme{"warning", Style{OpBold, FgYellow}}
|
|
// Light color style
|
|
Light = &Theme{"light", Style{FgLightWhite, BgBlack}}
|
|
// Error color style
|
|
Error = &Theme{"error", Style{FgLightWhite, BgRed}}
|
|
// Danger color style
|
|
Danger = &Theme{"danger", Style{OpBold, FgRed}}
|
|
// Debug color style
|
|
Debug = &Theme{"debug", Style{OpReset, FgCyan}}
|
|
// Notice color style
|
|
Notice = &Theme{"notice", Style{OpBold, FgCyan}}
|
|
// Comment color style
|
|
Comment = &Theme{"comment", Style{OpReset, FgYellow}}
|
|
// Success color style
|
|
Success = &Theme{"success", Style{OpBold, FgGreen}}
|
|
// Primary color style
|
|
Primary = &Theme{"primary", Style{OpReset, FgBlue}}
|
|
// Question color style
|
|
Question = &Theme{"question", Style{OpReset, FgMagenta}}
|
|
// Secondary color style
|
|
Secondary = &Theme{"secondary", Style{FgDarkGray}}
|
|
)
|
|
|
|
// Themes internal defined themes.
|
|
// Usage:
|
|
// color.Themes["info"].Println("message")
|
|
var Themes = map[string]*Theme{
|
|
"info": Info,
|
|
"note": Note,
|
|
"light": Light,
|
|
"error": Error,
|
|
|
|
"debug": Debug,
|
|
"danger": Danger,
|
|
"notice": Notice,
|
|
"success": Success,
|
|
"comment": Comment,
|
|
"primary": Primary,
|
|
"warning": Warn,
|
|
|
|
"question": Question,
|
|
"secondary": Secondary,
|
|
}
|
|
|
|
// AddTheme add a theme and style
|
|
func AddTheme(name string, style Style) {
|
|
Themes[name] = NewTheme(name, style)
|
|
Styles[name] = style
|
|
}
|
|
|
|
// GetTheme get defined theme by name
|
|
func GetTheme(name string) *Theme {
|
|
return Themes[name]
|
|
}
|
|
|
|
/*************************************************************
|
|
* internal styles
|
|
*************************************************************/
|
|
|
|
// Styles internal defined styles, like bootstrap styles.
|
|
// Usage:
|
|
// color.Styles["info"].Println("message")
|
|
var Styles = map[string]Style{
|
|
"info": {OpReset, FgGreen},
|
|
"note": {OpBold, FgLightCyan},
|
|
"light": {FgLightWhite, BgRed},
|
|
"error": {FgLightWhite, BgRed},
|
|
|
|
"danger": {OpBold, FgRed},
|
|
"notice": {OpBold, FgCyan},
|
|
"success": {OpBold, FgGreen},
|
|
"comment": {OpReset, FgMagenta},
|
|
"primary": {OpReset, FgBlue},
|
|
"warning": {OpBold, FgYellow},
|
|
|
|
"question": {OpReset, FgMagenta},
|
|
"secondary": {FgDarkGray},
|
|
}
|
|
|
|
// some style name alias
|
|
var styleAliases = map[string]string{
|
|
"err": "error",
|
|
"suc": "success",
|
|
"warn": "warning",
|
|
}
|
|
|
|
// AddStyle add a style
|
|
func AddStyle(name string, s Style) {
|
|
Styles[name] = s
|
|
}
|
|
|
|
// GetStyle get defined style by name
|
|
func GetStyle(name string) Style {
|
|
if s, ok := Styles[name]; ok {
|
|
return s
|
|
}
|
|
|
|
if realName, ok := styleAliases[name]; ok {
|
|
return Styles[realName]
|
|
}
|
|
|
|
// empty style
|
|
return New()
|
|
}
|
|
|
|
/*************************************************************
|
|
* color scheme
|
|
*************************************************************/
|
|
|
|
// Scheme struct
|
|
type Scheme struct {
|
|
Name string
|
|
Styles map[string]Style
|
|
}
|
|
|
|
// NewScheme create new Scheme
|
|
func NewScheme(name string, styles map[string]Style) *Scheme {
|
|
return &Scheme{Name: name, Styles: styles}
|
|
}
|
|
|
|
// NewDefaultScheme create an defuault color Scheme
|
|
func NewDefaultScheme(name string) *Scheme {
|
|
return NewScheme(name, map[string]Style{
|
|
"info": {OpReset, FgGreen},
|
|
"warn": {OpBold, FgYellow},
|
|
"error": {FgLightWhite, BgRed},
|
|
})
|
|
}
|
|
|
|
// Style get by name
|
|
func (s *Scheme) Style(name string) Style {
|
|
return s.Styles[name]
|
|
}
|
|
|
|
// Infof message print
|
|
func (s *Scheme) Infof(format string, a ...interface{}) {
|
|
s.Styles["info"].Printf(format, a...)
|
|
}
|
|
|
|
// Infoln message print
|
|
func (s *Scheme) Infoln(v ...interface{}) {
|
|
s.Styles["info"].Println(v...)
|
|
}
|
|
|
|
// Warnf message print
|
|
func (s *Scheme) Warnf(format string, a ...interface{}) {
|
|
s.Styles["warn"].Printf(format, a...)
|
|
}
|
|
|
|
// Warnln message print
|
|
func (s *Scheme) Warnln(v ...interface{}) {
|
|
s.Styles["warn"].Println(v...)
|
|
}
|
|
|
|
// Errorf message print
|
|
func (s *Scheme) Errorf(format string, a ...interface{}) {
|
|
s.Styles["error"].Printf(format, a...)
|
|
}
|
|
|
|
// Errorln message print
|
|
func (s *Scheme) Errorln(v ...interface{}) {
|
|
s.Styles["error"].Println(v...)
|
|
}
|