func main() {
	//Revel Example

	//first set some color information
	info := gocolorize.NewColor("green")
	warning := gocolorize.NewColor("yellow")

	critical := gocolorize.NewColor("black+u:red")
	//We could also do this
	//critical.ToggleUnderline()

	//helper functions to shorten code
	i := info.Paint
	w := warning.Paint
	c := critical.Paint

	//Define the look/feel of the INFO logger
	INFO = log.New(os.Stdout, i("INFO "), log.Ldate|log.Lmicroseconds|log.Lshortfile)
	WARNING = log.New(os.Stdout, w("WARNING "), log.Ldate|log.Lmicroseconds|log.Lshortfile)
	CRITICAL = log.New(os.Stdout, c("CRITICAL")+" ", log.Ldate|log.Lmicroseconds|log.Lshortfile)

	//print out some messages, note the i wrappers for yellow text on the actual info string
	INFO.Println(i("Loaded module x"))
	INFO.Println(i("Loaded module y"))
	WARNING.Println(w("Failed to load module z"))

	e := MyError{What: "Failed"}

	CRITICAL.Println(c("Failed with an error code:", e))

}

func (l *loggingT) getColorByte(s severity, b []byte) []byte {
	var c gocolorize.Colorize
	switch s {
	case warningLog:
		c = gocolorize.NewColor("yellow")
	case errorLog:
		c = gocolorize.NewColor("red")
	case fatalLog:
		c = gocolorize.NewColor("magenta")
	default:
		c = gocolorize.NewColor("green")
	}
	return []byte(c.Paint(string(b)))
}

func showDiff(oldText, newText string) {
	dmp := diffmatchpatch.New()
	diffs := dmp.DiffMain(oldText, newText, true)

	for _, diff := range diffs {
		switch diff.Type {
		case diffmatchpatch.DiffInsert:
			color := gocolorize.NewColor("green")
			printLinesWithPrefix(color.Paint("+"), diff.Text)
		case diffmatchpatch.DiffDelete:
			color := gocolorize.NewColor("red")
			printLinesWithPrefix(color.Paint("-"), diff.Text)
		}
	}
}

func main() {
	loggers.IsDebug = os.Getenv("GBW_DEBUG") == "1"
	fmt.Println(gocolorize.NewColor("magenta").Paint("gobuildweb > Build a Golang web application.\n"))

	cmds := map[string]Command{
		"run":  commandRun,
		"dist": commandDist,
	}
	flag.Parse()
	args := flag.Args()
	if len(args) == 0 {
		usage()
	}
	if cmd, ok := cmds[args[0]]; !ok {
		usage()
	} else {
		if fi, err := os.Stat("project.toml"); os.IsNotExist(err) {
			loggers.ERROR.Fatalf("Please provide a project.toml for web project.")
		} else if err != nil {
			loggers.ERROR.Fatalf("Accessing project.toml file error, %v.", err)
		} else if fi.IsDir() {
			loggers.ERROR.Fatalf("project.toml cannot be a directory.")
		}

		if _, err := toml.DecodeFile("project.toml", &rootConfig); err != nil {
			loggers.ERROR.Fatalf("Cannot decode the project.toml into TOML format, %v", err)
		}
		loggers.SUCC.Printf("Loaded project.toml... %s", rootConfig.Package.Name)
		if err := cmd(args[1:]); err != nil {
			loggers.ERROR.Fatalf("Executing command [%v] error, %v", args[0], err)
		}
	}
}

func Parse() {
	if runtime.GOOS == "windows" {
		gocolorize.SetPlain(true)
	}

	var err = gcfg.ReadFileInto(&AppCfg, "App.cfg")
	if err != nil {
		errorf("Missing App.cfg")
		os.Exit(1)
	}

	fmt.Fprintf(os.Stdout, gocolorize.NewColor("Blue").Paint(AppCfg.App.Header))
	flag.Usage = func() { usage(1) }
	flag.Parse()
	args := flag.Args()

	if len(args) < 1 || args[0] == "help" {
		if len(args) == 1 {
			usage(0)
		}
		if len(args) > 1 {
			for _, cmd := range commands {
				if cmd.Name() == args[1] {
					tmpl(os.Stdout, AppCfg.Template.helpTemplate, cmd)
					return
				}
			}
		}
		usage(2)
	}

	// Commands use panic to abort execution when something goes wrong.
	// Panics are logged at the point of error. Ignore those.
	defer func() {
		if err := recover(); err != nil {
			if _, ok := err.(LoggedError); !ok {
				// This panic was not expecred/logged.
				panic(err)
			}
			os.Exit(1)
		}
	}()

	for _, cmd := range commands {
		if cmd.Name() == args[0] {
			cmd.Run(args[1:])
			return
		}
	}

	errorf("Unknown command.\n Run '%q help' for usage", args[0])
}

func main() {
	// one way to define a stateful colorizer
	var green gocolorize.Colorize
	green.SetColor(gocolorize.Green)
	g := green.Paint

	// Another way to do it
	red := gocolorize.Colorize{Fg: gocolorize.Red}
	r := red.Paint

	// now with string construction
	green_black := gocolorize.Colorize{Fg: gocolorize.Blue}
	// toggle attributes
	green_black.ToggleUnderline()
	b := green_black.Paint

	//all in 1 line
	c := gocolorize.NewColor("yellow:black").Paint

	//r := gocolorize.COLOR_RED

	fmt.Println(b("On the twelfth day of Christmas"))
	fmt.Println(b("my true love sent to me:"))
	fmt.Println(g("Twelve"), c("Drummers"), r("Drumming"))
	fmt.Println(g("Eleven"), c("Pipers"), r("Piping"))
	fmt.Println(g("Ten"), c("Lords"), r("a Leaping"))
	fmt.Println(g("Nine"), c("Ladies"), r("Dancing"))
	fmt.Println(g("Eight"), c("Maids"), r("a Milking"))
	fmt.Println(g("Seven"), c("Swans"), r("a Swimming"))
	fmt.Println(g("Six"), c("Geese"), r("a Laying"))
	fmt.Println(g("Five"), c("Golden"), r("Rings"))
	fmt.Println(g("Four"), c("Calling"), r("Birds"))
	fmt.Println(g("Three"), c("French"), r("Hens"))
	fmt.Println(g("Two"), c("Turtle"), r("Doves"))
	fmt.Println(b("and a Partridge in a Pear Tree"))

}

	HttpSslKey  string // e.g. "/path/to/key.pem"

	// All cookies dropped by the framework begin with this prefix.
	CookiePrefix string
	// Cookie domain
	CookieDomain string
	// Cookie flags
	CookieHttpOnly bool
	CookieSecure   bool

	// Delimiters to use when rendering templates
	TemplateDelims string

	//Logger colors
	colors = map[string]gocolorize.Colorize{
		"trace": gocolorize.NewColor("magenta"),
		"info":  gocolorize.NewColor("green"),
		"warn":  gocolorize.NewColor("yellow"),
		"error": gocolorize.NewColor("red"),
	}

	error_log = revelLogs{c: colors["error"], w: os.Stderr}

	// Loggers
	TRACE = log.New(ioutil.Discard, "TRACE ", log.Ldate|log.Ltime|log.Lshortfile)
	INFO  = log.New(ioutil.Discard, "INFO  ", log.Ldate|log.Ltime|log.Lshortfile)
	WARN  = log.New(ioutil.Discard, "WARN  ", log.Ldate|log.Ltime|log.Lshortfile)
	ERROR = log.New(&error_log, "ERROR ", log.Ldate|log.Ltime|log.Lshortfile)

	Initialized bool

	Long: `sync checks the GOPATH for consistency with the given package's GLOCKFILE

For example:

	glock sync github.com/robfig/glock

It verifies that each entry in the GLOCKFILE is at the expected revision.
If a dependency is not at the expected revision, it is re-downloaded and synced.
Commands are built if necessary.
`,
}

var (
	color = flag.Bool("color", true, "if true, colorize terminal output")

	info     = gocolorize.NewColor("green").Paint
	warning  = gocolorize.NewColor("yellow").Paint
	critical = gocolorize.NewColor("red").Paint

	disabled = func(args ...interface{}) string { return fmt.Sprint(args...) }
)

func init() {
	cmdSync.Run = runSync // break init loop
}

func runSync(cmd *Command, args []string) {
	if len(args) == 0 {
		cmdSync.Usage()
		return
	}

func init() {
	INFO = log.New(os.Stdout, "(gbw) [INFO] ", 0)
	SUCC = log.New(&ColoredLogger{gocolorize.NewColor("green"), os.Stdout}, "(gbw) [SUCC] ", 0)
	WARN = log.New(&ColoredLogger{gocolorize.NewColor("yellow"), os.Stdout}, "(gbw) [WARN] ", 0)
	ERROR = log.New(&ColoredLogger{gocolorize.NewColor("red"), os.Stdout}, "(gbw) [ERROR] ", 0)
}

package cli

import (
	"fmt"

	"github.com/agtorre/gocolorize"
	"github.com/kr/beanstalk"
)

var TitleStyle = gocolorize.NewColor("green")
var InfoStyle = gocolorize.NewColor("yellow")

type Command struct {
	Host string `short:"h" long:"host" description:"beanstalkd host addr." required:"true" default:"localhost:11300"`

	conn *beanstalk.Conn
}

func (c *Command) Init() error {
	var err error
	c.conn, err = beanstalk.Dial("tcp", c.Host)
	if err != nil {
		return err
	}

	return nil
}

func (c *Command) PrintJob(id uint64, body []byte) error {
	s, err := c.conn.StatsJob(id)
	if err != nil {

package wlog

import (
	"fmt"
	"github.com/agtorre/gocolorize"
	"github.com/mabetle/mcore/mterm"
)

var (
	trace = gocolorize.NewColor("magenta")
	debug = gocolorize.NewColor("cyan")
	info  = gocolorize.NewColor("green")
	warn  = gocolorize.NewColor("yellow")
	err   = gocolorize.NewColor("red")

	//helper functions to longen code
	d = debug.Paint
	i = info.Paint
	w = warn.Paint
	e = err.Paint
	t = trace.Paint
)

func GetLevelColorMsg(level string, v ...interface{}) string {
	// default no color.
	msg := fmt.Sprint(v...)
	levelLevel := GetStringLevel(level)

	// xterm can show color.
	if mterm.IsXterm() {
		switch levelLevel {

	"fmt"
	"strconv"
	"strings"

	"github.com/agtorre/gocolorize"
	"github.com/mcuadros/termtable"
)

const (
	HighSeverity = iota
	NormalSeverity
	LowSeverity
)

var TubeStatsRetrievalError = errors.New("Unable to retrieve tube stats")
var HighSeverityStyle = gocolorize.NewColor("white:red")
var NormalSeverityStyle = gocolorize.NewColor("green")

type StatsCommand struct {
	Tubes string `short:"t" long:"tubes" description:"tubes to be listed (separated by ,). By default all are listed"`

	Command
}

func (c *StatsCommand) Execute(args []string) error {
	if err := c.Init(); err != nil {
		return err
	}

	if err := c.PrintStats(); err != nil {
		return err