From 38c9fd2510fa896f7144013fadf2702fa1226f80 Mon Sep 17 00:00:00 2001
From: Antoine Grondin <antoinegrondin@gmail.com>
Date: Mon, 7 Sep 2015 20:47:46 -0400
Subject: [PATCH] Revert "Implement casting of *Entry to error."

This reverts commit 756db3cd2dd0d5a461aeefd25cbe5223d4f06d9f.
---
 entry.go      | 68 ++++++++++++++++++---------------------------------
 entry_test.go | 19 ++------------
 2 files changed, 26 insertions(+), 61 deletions(-)

diff --git a/entry.go b/entry.go
index 1e97f99..9ae900b 100644
--- a/entry.go
+++ b/entry.go
@@ -56,14 +56,6 @@ func (entry *Entry) String() (string, error) {
 	return reader.String(), err
 }
 
-// ToError returns the field value of ErrorKey (nil)
-func (entry *Entry) ToError() error {
-	if err, ok := entry.Data[ErrorKey].(error); ok {
-		return err
-	}
-	return nil
-}
-
 // Add an error as single field (using the key defined in ErrorKey) to the Entry.
 func (entry *Entry) WithError(err error) *Entry {
 	return entry.WithField(ErrorKey, err)
@@ -122,40 +114,36 @@ func (entry Entry) log(level Level, msg string) {
 	}
 }
 
-func (entry *Entry) Debug(args ...interface{}) *Entry {
+func (entry *Entry) Debug(args ...interface{}) {
 	if entry.Logger.Level >= DebugLevel {
 		entry.log(DebugLevel, fmt.Sprint(args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Print(args ...interface{}) *Entry {
-	return entry.Info(args...)
+func (entry *Entry) Print(args ...interface{}) {
+	entry.Info(args...)
 }
 
-func (entry *Entry) Info(args ...interface{}) *Entry {
+func (entry *Entry) Info(args ...interface{}) {
 	if entry.Logger.Level >= InfoLevel {
 		entry.log(InfoLevel, fmt.Sprint(args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Warn(args ...interface{}) *Entry {
+func (entry *Entry) Warn(args ...interface{}) {
 	if entry.Logger.Level >= WarnLevel {
 		entry.log(WarnLevel, fmt.Sprint(args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Warning(args ...interface{}) *Entry {
-	return entry.Warn(args...)
+func (entry *Entry) Warning(args ...interface{}) {
+	entry.Warn(args...)
 }
 
-func (entry *Entry) Error(args ...interface{}) *Entry {
+func (entry *Entry) Error(args ...interface{}) {
 	if entry.Logger.Level >= ErrorLevel {
 		entry.log(ErrorLevel, fmt.Sprint(args...))
 	}
-	return entry
 }
 
 func (entry *Entry) Fatal(args ...interface{}) {
@@ -174,40 +162,36 @@ func (entry *Entry) Panic(args ...interface{}) {
 
 // Entry Printf family functions
 
-func (entry *Entry) Debugf(format string, args ...interface{}) *Entry {
+func (entry *Entry) Debugf(format string, args ...interface{}) {
 	if entry.Logger.Level >= DebugLevel {
 		entry.Debug(fmt.Sprintf(format, args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Infof(format string, args ...interface{}) *Entry {
+func (entry *Entry) Infof(format string, args ...interface{}) {
 	if entry.Logger.Level >= InfoLevel {
 		entry.Info(fmt.Sprintf(format, args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Printf(format string, args ...interface{}) *Entry {
-	return entry.Infof(format, args...)
+func (entry *Entry) Printf(format string, args ...interface{}) {
+	entry.Infof(format, args...)
 }
 
-func (entry *Entry) Warnf(format string, args ...interface{}) *Entry {
+func (entry *Entry) Warnf(format string, args ...interface{}) {
 	if entry.Logger.Level >= WarnLevel {
 		entry.Warn(fmt.Sprintf(format, args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Warningf(format string, args ...interface{}) *Entry {
-	return entry.Warnf(format, args...)
+func (entry *Entry) Warningf(format string, args ...interface{}) {
+	entry.Warnf(format, args...)
 }
 
-func (entry *Entry) Errorf(format string, args ...interface{}) *Entry {
+func (entry *Entry) Errorf(format string, args ...interface{}) {
 	if entry.Logger.Level >= ErrorLevel {
 		entry.Error(fmt.Sprintf(format, args...))
 	}
-	return entry
 }
 
 func (entry *Entry) Fatalf(format string, args ...interface{}) {
@@ -225,40 +209,36 @@ func (entry *Entry) Panicf(format string, args ...interface{}) {
 
 // Entry Println family functions
 
-func (entry *Entry) Debugln(args ...interface{}) *Entry {
+func (entry *Entry) Debugln(args ...interface{}) {
 	if entry.Logger.Level >= DebugLevel {
 		entry.Debug(entry.sprintlnn(args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Infoln(args ...interface{}) *Entry {
+func (entry *Entry) Infoln(args ...interface{}) {
 	if entry.Logger.Level >= InfoLevel {
 		entry.Info(entry.sprintlnn(args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Println(args ...interface{}) *Entry {
-	return entry.Infoln(args...)
+func (entry *Entry) Println(args ...interface{}) {
+	entry.Infoln(args...)
 }
 
-func (entry *Entry) Warnln(args ...interface{}) *Entry {
+func (entry *Entry) Warnln(args ...interface{}) {
 	if entry.Logger.Level >= WarnLevel {
 		entry.Warn(entry.sprintlnn(args...))
 	}
-	return entry
 }
 
-func (entry *Entry) Warningln(args ...interface{}) *Entry {
-	return entry.Warnln(args...)
+func (entry *Entry) Warningln(args ...interface{}) {
+	entry.Warnln(args...)
 }
 
-func (entry *Entry) Errorln(args ...interface{}) *Entry {
+func (entry *Entry) Errorln(args ...interface{}) {
 	if entry.Logger.Level >= ErrorLevel {
 		entry.Error(entry.sprintlnn(args...))
 	}
-	return entry
 }
 
 func (entry *Entry) Fatalln(args ...interface{}) {
diff --git a/entry_test.go b/entry_test.go
index 3473ffb..99c3b41 100644
--- a/entry_test.go
+++ b/entry_test.go
@@ -8,23 +8,6 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-var err = fmt.Errorf("kaboom at layer %d", 4711)
-
-func TestToError(t *testing.T) {
-
-	assert := assert.New(t)
-
-	ctx := WithField("foo", "bar")
-	assert.Equal(nil, ctx.Debug("Hello").ToError())
-
-	ctx.Data[ErrorKey] = "error"
-	assert.Equal(nil, ctx.Debug("Hello").ToError())
-
-	ctx = ctx.WithError(err)
-	assert.Equal(err, ctx.Debug("Hello").ToError())
-
-}
-
 func TestEntryWithError(t *testing.T) {
 
 	assert := assert.New(t)
@@ -33,6 +16,8 @@ func TestEntryWithError(t *testing.T) {
 		ErrorKey = "error"
 	}()
 
+	err := fmt.Errorf("kaboom at layer %d", 4711)
+
 	assert.Equal(err, WithError(err).Data["error"])
 
 	logger := New()