Simplified Formatter interface and package implementation

Author: cmaglie

common/formatter/examples_test.go

@@ -59,14 +59,14 @@ func ExampleJSONFormatter_Print() {
 	example.Field3.Inner2 = 10.432412
 
 	var jf formatter.JSONFormatter
-	jf.Print(example)
+	fmt.Println(jf.Format(example))
 
 	var example2 float64 = 3.14
-	jf.Print(example2)
+	fmt.Println(jf.Format(example2))
 
 	// Output:
-	// {"field1":"test","field2":10,"field3":{"inner1":"inner test","inner2":10.432412}}
-	//
+	// {"field1":"test","field2":10,"field3":{"inner1":"inner test","inner2":10.432412}} <nil>
+	//  float64 ignored
 }
 
 func ExampleJSONFormatter_Format() {
@@ -85,25 +85,14 @@ func ExampleJSONFormatter_Format() {
 	example.Field3.Inner2 = 10.432412
 
 	var jf formatter.JSONFormatter
-	var result string
-	result, err := jf.Format(example)
-	if err != nil {
-		fmt.Println("ERROR:", err)
-	} else {
-		fmt.Println("RESULT:", result)
-	}
+	fmt.Println(jf.Format(example))
 
 	var example2 float32 = 3.14
-	result, err = jf.Format(example2)
-	if err != nil {
-		fmt.Println("ERROR:", err)
-	} else if result == "" {
-		fmt.Println("RESULT: <empty string>")
-	}
+	fmt.Println(jf.Format(example2))
 
 	// Output:
-	// RESULT: {"field1":"test","field2":10,"field3":{"inner1":"inner test","inner2":10.432412}}
-	// RESULT: <empty string>
+	// {"field1":"test","field2":10,"field3":{"inner1":"inner test","inner2":10.432412}} <nil>
+	//  float32 ignored
 }
 
 func ExampleJSONFormatter_Print_debug() {
@@ -112,58 +101,39 @@ func ExampleJSONFormatter_Print_debug() {
 	jf := formatter.JSONFormatter{
 		Debug: false,
 	}
-	//using struct
-	jf.Print(valid)
+	// using struct
+	fmt.Println(jf.Format(valid))
 
-	//using string (invalid sine it's not a struct or a map)
-	jf.Print(invalid)
+	// using string (invalid sine it's not a struct or a map)
+	fmt.Println(jf.Format(invalid))
 
 	jf.Debug = true
-	jf.Print(valid)
-	jf.Print(invalid)
+	fmt.Println(jf.Format(valid))
+	fmt.Println(jf.Format(invalid))
 
-	//using map
+	// using map
 	newValue := make(map[string]int)
 	newValue["value2"] = 10
 
-	jf.Print(newValue)
+	fmt.Println(jf.Format(newValue))
+
 	// Output:
-	// {"value":20}
-	// {"value":20}
-	// Only structs and maps values are accepted
-	// {"value2":10}
+	// {"value":20} <nil>
+	//  string ignored
+	// {"value":20} <nil>
+	//  string ignored
+	// {"value2":10} <nil>
 }
 
 func ExampleFormat() {
 	formatter.SetFormatter("text")
-	result, err := formatter.Format(TestStruct{5})
-	if err == nil {
-		fmt.Println("RESULT: ", result)
-	} else {
-		fmt.Println("ERROR: ", err)
-	}
-
+	fmt.Println(formatter.Format(TestStruct{5}))
 	formatter.SetFormatter("json")
-	result, err = formatter.Format(TestStruct{10})
-	if err == nil {
-		fmt.Println("RESULT: ", result)
-	} else {
-		fmt.Println("ERROR: ", err)
-	}
-	result, err = formatter.Format(5)
-	if err == nil {
-		if result == "" {
-			result = "<empty string>"
-			fmt.Println("RESULT: ", result)
-		} else {
-			fmt.Println("unexpected RESULT: ", result)
-		}
-	} else {
-		fmt.Sprintln("ERROR: ", err)
-	}
+	fmt.Println(formatter.Format(TestStruct{10}))
+	fmt.Println(formatter.Format(5))
 
 	// Output:
-	// RESULT:  VALUE = 5
-	// RESULT:  {"value":10}
-	// RESULT:  <empty string>
+	// VALUE = 5 <nil>
+	// {"value":10} <nil>
+	//  int ignored
 }

common/formatter/formatter.go

@@ -32,15 +32,13 @@ package formatter
 import (
 	"errors"
 	"fmt"
-	"strings"
 
 	"github.com/sirupsen/logrus"
 )
 
 // Formatter interface represents a generic formatter. It allows to print and format Messages.
 type Formatter interface {
 	Format(interface{}) (string, error) // Format formats a parameter if possible, otherwise it returns an error.
-	Print(interface{}) error            // Print just prints specified parameter, returns error if it is not parsable.
 }
 
 // PrintFunc represents a function used to print formatted data.
@@ -49,8 +47,6 @@ type PrintFunc func(Formatter, interface{}) error
 var formatters map[string]Formatter
 var defaultFormatter Formatter
 
-var printFunc PrintFunc
-
 var logger *logrus.Logger
 
 var debug bool
@@ -60,8 +56,6 @@ func init() {
 	AddCustomFormatter("text", &TextFormatter{})
 	AddCustomFormatter("json", &JSONFormatter{})
 	defaultFormatter = formatters["text"]
-
-	printFunc = defaultPrintFunc
 }
 
 // SetFormatter sets the defaults format to the one specified, if valid. Otherwise it returns an error.
@@ -111,28 +105,10 @@ func Format(msg interface{}) (string, error) {
 
 // Print prints a message formatted using a Formatter specified by SetFormatter(...) function.
 func Print(msg interface{}) error {
-	if defaultFormatter == nil {
-		return errors.New("No formatter set")
-	}
-	return defaultFormatter.Print(msg)
-}
-
-// defaultPrintFunc is the base function of all Print methods of Formatters.
-//
-// It can be used for an unified implementation.
-func defaultPrintFunc(f Formatter, msg interface{}) error {
-	val, err := f.Format(msg)
-	if val != "" {
-		if err == nil {
-			fmt.Println(strings.TrimSpace(val))
-		} else {
-			fmt.Println(strings.TrimSpace(err.Error()))
-		}
+	output, err := defaultFormatter.Format(msg)
+	if err != nil {
+		return err
 	}
-	return err
-}
-
-// SetPrintFunc changes the actual print function with a specified one.
-func SetPrintFunc(p PrintFunc) {
-	printFunc = p
+	fmt.Println(output)
+	return nil
 }

common/formatter/json.go

@@ -31,30 +31,23 @@ package formatter
 
 import "encoding/json"
 import "reflect"
-import "errors"
+
 import "fmt"
 
-//JSONFormatter represents a Printer and Formatter of JSON objects.
+// JSONFormatter is a Formatter that output JSON objects.
+// Intermediate results or interactive messages are ignored.
 type JSONFormatter struct {
-	Debug bool //if false, errors are not shown. Unparsable inputs are skipped. Otherwise an error message is shown.
+	Debug bool // if false, errors are not shown. Unparsable inputs are skipped. Otherwise an error message is shown.
 }
 
-// Format formaats a message into a JSON object.
-//
-// It ignores Header and Footer fields of the message.
+// Format implements Formatter interface
 func (jf JSONFormatter) Format(msg interface{}) (string, error) {
-	msgType := reflect.TypeOf(msg).Kind().String()
-	if msgType == "struct" ||
-		msgType == "map" {
+	t := reflect.TypeOf(msg).Kind().String()
+	switch t {
+	case "struct", "map":
 		ret, err := json.Marshal(msg)
 		return string(ret), err
-	} else if jf.Debug {
-		return fmt.Sprint(msg), errors.New("Only structs and maps values are accepted")
+	default:
+		return "", fmt.Errorf("%s ignored", t)
 	}
-	return "", nil
-}
-
-// Print prints a JSON object.
-func (jf JSONFormatter) Print(msg interface{}) error {
-	return printFunc(jf, msg)
 }

common/formatter/print_test.go

@@ -62,12 +62,10 @@ func ExamplePrint() {
 
 	formatter.SetFormatter("json")
 	formatter.Print(example)
-	fmt.Println() //to separe outputs
 	formatter.SetFormatter("text")
 	formatter.Print(example)
 	// Output:
 	// {"field1":"test","field2":10,"field3":{"inner1":"inner test","inner2":10.432412}}
-	//
 	// Field1: test
 	// Field2: 10
 	// Field3.Inner1: inner test

common/formatter/text.go

@@ -31,17 +31,10 @@ package formatter
 
 import "fmt"
 
-//TextFormatter represents a Printer and Formatter of Text.
+// TextFormatter represents a Formatter for a text console
 type TextFormatter struct{}
 
-// Format formaats a message into a JSON object.
-//
-// It ignores Header and Footer fields of the message.
+// Format implements Formatter interface
 func (tp TextFormatter) Format(msg interface{}) (string, error) {
 	return fmt.Sprintf("%s", msg), nil
 }
-
-// Print prints a JSON object.
-func (tp TextFormatter) Print(msg interface{}) error {
-	return printFunc(tp, msg)
-}