Merge pull request #5 from is2ei/use-aurora

Use github.com/logrusorgru/aurora instead of github.com/fatih/color

Author: mingrammer

cfmt.go

@@ -1,211 +1,217 @@
 package cfmt
 
 import (
+	"fmt"
 	"io"
 
-	"github.com/fatih/color"
+	"github.com/logrusorgru/aurora"
+	"github.com/mattn/go-colorable"
+)
+
+var (
+	output = colorable.NewColorableStdout()
 )
 
 // Fsuccessf writes green colored text in manner of fmt.Fprintf
 func Fsuccessf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgGreen).Fprintf(w, format, a...)
+	n, err = fmt.Fprint(w, aurora.Sprintf(aurora.Green(format), a...))
 	return
 }
 
 // Successf prints green colored text in manner of fmt.Printf
 func Successf(format string, a ...interface{}) (n int, err error) {
-	n, err = Fsuccessf(color.Output, format, a...)
+	n, err = Fsuccessf(output, format, a...)
 	return
 }
 
 // Ssuccessf returns green colored string in manner of fmt.Sprintf
 func Ssuccessf(format string, a ...interface{}) string {
-	return color.New(color.FgGreen).Sprintf(format, a...)
+	return aurora.Sprintf(aurora.Green(format), a...)
 }
 
 // Finfof writes cyan colored text in manner of fmt.Fprintf
 func Finfof(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgCyan).Fprintf(w, format, a...)
+	n, err = fmt.Fprint(w, aurora.Sprintf(aurora.Cyan(format), a...))
 	return
 }
 
 // Infof prints cyan colored text in manner of fmt.Printf
 func Infof(format string, a ...interface{}) (n int, err error) {
-	n, err = Finfof(color.Output, format, a...)
+	n, err = Finfof(output, format, a...)
 	return
 }
 
 // Sinfof returns cyan colored string in manner of fmt.Sprintf
 func Sinfof(format string, a ...interface{}) string {
-	return color.New(color.FgCyan).Sprintf(format, a...)
+	return aurora.Sprintf(aurora.Cyan(format), a...)
 }
 
 // Fwarningf writes yellow colored text in manner of fmt.Fprintf
 func Fwarningf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgYellow).Fprintf(w, format, a...)
+	n, err = fmt.Fprint(w, aurora.Sprintf(aurora.Brown(format), a...))
 	return
 }
 
 // Warningf prints yellow colored text in manner of fmt.Printf
 func Warningf(format string, a ...interface{}) (n int, err error) {
-	n, err = Fwarningf(color.Output, format, a...)
+	n, err = Fwarningf(output, format, a...)
 	return
 }
 
 // Swarningf returns yellow colored string in manner of fmt.Sprintf
 func Swarningf(format string, a ...interface{}) string {
-	return color.New(color.FgYellow).Sprintf(format, a...)
+	return aurora.Sprintf(aurora.Brown(format), a...)
 }
 
 // Ferrorf writes red colored text in manner of fmt.Fprintf
 func Ferrorf(w io.Writer, format string, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgRed).Fprintf(w, format, a...)
+	n, err = fmt.Fprint(w, aurora.Sprintf(aurora.Red(format), a...))
 	return
 }
 
 // Errorf prints red colored text in manner of fmt.Printf
 func Errorf(format string, a ...interface{}) (n int, err error) {
-	n, err = Ferrorf(color.Output, format, a...)
+	n, err = Ferrorf(output, format, a...)
 	return
 }
 
 // Serrorf returns red colored string in manner of fmt.Sprintf
 func Serrorf(format string, a ...interface{}) string {
-	return color.New(color.FgRed).Sprintf(format, a...)
+	return aurora.Sprintf(aurora.Red(format), a...)
 }
 
 // Fsuccess prints green colored text in manner of fmt.Fprint
 func Fsuccess(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgGreen).Fprint(w, a...)
+	n, err = fmt.Fprint(w, aurora.Green(fmt.Sprint(a...)))
 	return
 }
 
 // Success prints green colored text in manner of fmt.Print
 func Success(a ...interface{}) (n int, err error) {
-	n, err = Fsuccess(color.Output, a...)
+	n, err = Fsuccess(output, a...)
 	return
 }
 
 // Ssuccess returns green colored string in manner of fmt.Sprint
 func Ssuccess(a ...interface{}) string {
-	return color.New(color.FgGreen).Sprint(a...)
+	return fmt.Sprint(aurora.Green(fmt.Sprint(a...)))
 }
 
 // Finfo prints cyan colored text in manner of fmt.Fprint
 func Finfo(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgCyan).Fprint(w, a...)
+	n, err = fmt.Fprint(w, aurora.Cyan(fmt.Sprint(a...)))
 	return
 }
 
 // Info prints cyan colored text in manner of fmt.Print
 func Info(a ...interface{}) (n int, err error) {
-	n, err = Finfo(color.Output, a...)
+	n, err = Finfo(output, a...)
 	return
 }
 
 // Sinfo returns cyan colored string in manner of fmt.Sprint
 func Sinfo(a ...interface{}) string {
-	return color.New(color.FgCyan).Sprint(a...)
+	return fmt.Sprint(aurora.Cyan(fmt.Sprint(a...)))
 }
 
 // Fwarning prints yellow colored text in manner of fmt.Fprint
 func Fwarning(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgYellow).Fprint(w, a...)
+	n, err = fmt.Fprint(w, aurora.Brown(fmt.Sprint(a...)))
 	return
 }
 
 // Warning prints yellow colored text in manner of fmt.Print
 func Warning(a ...interface{}) (n int, err error) {
-	n, err = Fwarning(color.Output, a...)
+	n, err = Fwarning(output, a...)
 	return
 }
 
 // Swarning returns yellow colored string in manner of fmt.Sprint
 func Swarning(a ...interface{}) string {
-	return color.New(color.FgYellow).Sprint(a...)
+	return fmt.Sprint(aurora.Brown(fmt.Sprint(a...)))
 }
 
 // Ferror prints red colored text in manner of fmt.Fprint
 func Ferror(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgRed).Fprint(w, a...)
+	n, err = fmt.Fprint(w, aurora.Red(fmt.Sprint(a...)))
 	return
 }
 
 // Error prints red colored text in manner of fmt.Print
 func Error(a ...interface{}) (n int, err error) {
-	n, err = Ferror(color.Output, a...)
+	n, err = Ferror(output, a...)
 	return
 }
 
 // Serror returns red colored string in manner of fmt.Sprint
 func Serror(a ...interface{}) string {
-	return color.New(color.FgRed).Sprint(a...)
+	return fmt.Sprint(aurora.Red(fmt.Sprint(a...)))
 }
 
 // Fsuccessln prints green colored text in manner of fmt.Fprintln
 func Fsuccessln(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgGreen).Fprintln(w, a...)
+	n, err = fmt.Fprintln(w, aurora.Green(fmt.Sprint(a...)))
 	return
 }
 
 // Successln prints green colored text in manner of fmt.Println
 func Successln(a ...interface{}) (n int, err error) {
-	n, err = Fsuccessln(color.Output, a...)
+	n, err = Fsuccessln(output, a...)
 	return
 }
 
 // Ssuccessln returns green colored string in manner of fmt.Sprintln
 func Ssuccessln(a ...interface{}) string {
-	return color.New(color.FgGreen).Sprintln(a...)
+	return fmt.Sprintln(aurora.Green(fmt.Sprint(a...)))
 }
 
 // Finfoln prints cyan colored text in manner of fmt.Fprintln
 func Finfoln(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgCyan).Fprintln(w, a...)
+	n, err = fmt.Fprintln(w, aurora.Cyan(fmt.Sprint(a...)))
 	return
 }
 
 // Infoln prints cyan colored text in manner of fmt.Println
 func Infoln(a ...interface{}) (n int, err error) {
-	n, err = Finfoln(color.Output, a...)
+	n, err = Finfoln(output, a...)
 	return
 }
 
 // Sinfoln returns cyan colored string in manner of fmt.Sprintln
 func Sinfoln(a ...interface{}) string {
-	return color.New(color.FgCyan).Sprintln(a...)
+	return fmt.Sprintln(aurora.Cyan(fmt.Sprint(a...)))
 }
 
 // Fwarningln prints yellow colored text in manner of fmt.Fprintln
 func Fwarningln(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgYellow).Fprintln(w, a...)
+	n, err = fmt.Fprintln(w, aurora.Brown(fmt.Sprint(a...)))
 	return
 }
 
 // Warningln prints yellow colored text in manner of fmt.Println
 func Warningln(a ...interface{}) (n int, err error) {
-	n, err = Fwarningln(color.Output, a...)
+	n, err = Fwarningln(output, a...)
 	return
 }
 
 // Swarningln returns yellow colored string in manner of fmt.Sprintln
 func Swarningln(a ...interface{}) string {
-	return color.New(color.FgYellow).Sprintln(a...)
+	return fmt.Sprintln(aurora.Brown(fmt.Sprint(a...)))
 }
 
 // Ferrorln prints red colored text in manner of fmt.Fprintln
 func Ferrorln(w io.Writer, a ...interface{}) (n int, err error) {
-	n, err = color.New(color.FgRed).Fprintln(w, a...)
+	n, err = fmt.Fprintln(w, aurora.Red(fmt.Sprint(a...)))
 	return
 }
 
 // Errorln prints red colored text in manner of fmt.Println
 func Errorln(a ...interface{}) (n int, err error) {
-	n, err = Ferrorln(color.Output, a...)
+	n, err = Ferrorln(output, a...)
 	return
 }
 
 // Serrorln returns red colored string in manner of fmt.Sprintln
 func Serrorln(a ...interface{}) string {
-	return color.New(color.FgRed).Sprintln(a...)
+	return fmt.Sprintln(aurora.Red(fmt.Sprint(a...)))
 }