@@ -11,7 +11,7 @@ github.com/Microsoft/opengcs a10967154e143a36014584a6f664344e3bb0aa64

 github.com/konsorten/go-windows-terminal-sequences v1.0.1

 github.com/kr/pty 5cf931ef8f

 github.com/mattn/go-shellwords v1.0.3

-github.com/sirupsen/logrus v1.3.0

+github.com/sirupsen/logrus 8bdbc7bcc01dcbb8ec23dc8a28e332258d25251f # v1.4.1

 github.com/tchap/go-patricia v2.2.6

 github.com/vdemeester/shakers 24d7f1d6a71aa5d9cbe7390e4afb66b7eef9e1b3

 golang.org/x/net a680a1efc54dd51c040b3b5ce4939ea3cf2ea0d1

@@ -365,6 +365,7 @@ Third party logging formatters:

 * [`logstash`](https://github.com/bshuster-repo/logrus-logstash-hook). Logs fields as [Logstash](http://logstash.net) Events.

 * [`prefixed`](https://github.com/x-cray/logrus-prefixed-formatter). Displays log entry source along with alternative layout.

 * [`zalgo`](https://github.com/aybabtme/logzalgo). Invoking the P͉̫o̳̼̊w̖͈̰͎e̬͔̭͂r͚̼̹̲ ̫͓͉̳͈ō̠͕͖̚f̝͍̠ ͕̲̞͖͑Z̖̫̤̫ͪa͉̬͈̗l͖͎g̳̥o̰̥̅!̣͔̲̻͊̄ ̙̘̦̹̦.

+* [`nested-logrus-formatter`](https://github.com/antonfisher/nested-logrus-formatter). Converts logrus fields to a nested structure.

 You can define your formatter by implementing the `Formatter` interface,

 requiring a `Format` method. `Format` takes an `*Entry`. `entry.Data` is a

@@ -51,9 +51,9 @@ func Exit(code int) {

 	os.Exit(code)

 }

-// RegisterExitHandler adds a Logrus Exit handler, call logrus.Exit to invoke

-// all handlers. The handlers will also be invoked when any Fatal log entry is

-// made.

+// RegisterExitHandler appends a Logrus Exit handler to the list of handlers,

+// call logrus.Exit to invoke all handlers. The handlers will also be invoked when

+// any Fatal log entry is made.

 //

 // This method is useful when a caller wishes to use logrus to log a fatal

 // message but also needs to gracefully shutdown. An example usecase could be

@@ -62,3 +62,15 @@ func Exit(code int) {

 func RegisterExitHandler(handler func()) {

 	handlers = append(handlers, handler)

 }

+

+// DeferExitHandler prepends a Logrus Exit handler to the list of handlers,

+// call logrus.Exit to invoke all handlers. The handlers will also be invoked when

+// any Fatal log entry is made.

+//

+// This method is useful when a caller wishes to use logrus to log a fatal

+// message but also needs to gracefully shutdown. An example usecase could be

+// closing database connections, or sending a alert that the application is

+// closing.

+func DeferExitHandler(handler func()) {

+	handlers = append([]func(){handler}, handlers...)

+}

@@ -2,6 +2,7 @@ package logrus

 import (

 	"bytes"

+	"context"

 	"fmt"

 	"os"

 	"reflect"

@@ -69,6 +70,9 @@ type Entry struct {

 	// When formatter is called in entry.log(), a Buffer may be set to entry

 	Buffer *bytes.Buffer

+	// Contains the context set by the user. Useful for hook processing etc.

+	Context context.Context

+

 	// err may contain a field formatting error

 	err string

 }

@@ -97,6 +101,11 @@ func (entry *Entry) WithError(err error) *Entry {

 	return entry.WithField(ErrorKey, err)

 }

+// Add a context to the Entry.

+func (entry *Entry) WithContext(ctx context.Context) *Entry {

+	return &Entry{Logger: entry.Logger, Data: entry.Data, Time: entry.Time, err: entry.err, Context: ctx}

+}

+

 // Add a single field to the Entry.

 func (entry *Entry) WithField(key string, value interface{}) *Entry {

 	return entry.WithFields(Fields{key: value})

@@ -130,12 +139,12 @@ func (entry *Entry) WithFields(fields Fields) *Entry {

 			data[k] = v

 		}

 	}

-	return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr}

+	return &Entry{Logger: entry.Logger, Data: data, Time: entry.Time, err: fieldErr, Context: entry.Context}

 }

 // Overrides the time of the Entry.

 func (entry *Entry) WithTime(t time.Time) *Entry {

-	return &Entry{Logger: entry.Logger, Data: entry.Data, Time: t, err: entry.err}

+	return &Entry{Logger: entry.Logger, Data: entry.Data, Time: t, err: entry.err, Context: entry.Context}

 }

 // getPackageName reduces a fully qualified function name to the package name

@@ -156,20 +165,23 @@ func getPackageName(f string) string {

 // getCaller retrieves the name of the first non-logrus calling function

 func getCaller() *runtime.Frame {

-	// Restrict the lookback frames to avoid runaway lookups

-	pcs := make([]uintptr, maximumCallerDepth)

-	depth := runtime.Callers(minimumCallerDepth, pcs)

-	frames := runtime.CallersFrames(pcs[:depth])

 	// cache this package's fully-qualified name

 	callerInitOnce.Do(func() {

-		logrusPackage = getPackageName(runtime.FuncForPC(pcs[0]).Name())

+		pcs := make([]uintptr, 2)

+		_ = runtime.Callers(0, pcs)

+		logrusPackage = getPackageName(runtime.FuncForPC(pcs[1]).Name())

 		// now that we have the cache, we can skip a minimum count of known-logrus functions

-		// XXX this is dubious, the number of frames may vary store an entry in a logger interface

+		// XXX this is dubious, the number of frames may vary

 		minimumCallerDepth = knownLogrusFrames

 	})

+	// Restrict the lookback frames to avoid runaway lookups

+	pcs := make([]uintptr, maximumCallerDepth)

+	depth := runtime.Callers(minimumCallerDepth, pcs)

+	frames := runtime.CallersFrames(pcs[:depth])

+

 	for f, again := frames.Next(); again; f, again = frames.Next() {

 		pkg := getPackageName(f.Function)

@@ -298,7 +310,9 @@ func (entry *Entry) Panic(args ...interface{}) {

 // Entry Printf family functions

 func (entry *Entry) Logf(level Level, format string, args ...interface{}) {

-	entry.Log(level, fmt.Sprintf(format, args...))

+	if entry.Logger.IsLevelEnabled(level) {

+		entry.Log(level, fmt.Sprintf(format, args...))

+	}

 }

 func (entry *Entry) Tracef(format string, args ...interface{}) {

@@ -1,6 +1,7 @@

 package logrus

 import (

+	"context"

 	"io"

 	"time"

 )

@@ -55,6 +56,11 @@ func WithError(err error) *Entry {

 	return std.WithField(ErrorKey, err)

 }

+// WithContext creates an entry from the standard logger and adds a context to it.

+func WithContext(ctx context.Context) *Entry {

+	return std.WithContext(ctx)

+}

+

 // WithField creates an entry from the standard logger and adds a field to

 // it. If you want multiple fields, use `WithFields`.

 //

@@ -4,6 +4,7 @@ import (

 	"bytes"

 	"encoding/json"

 	"fmt"

+	"runtime"

 )

 type fieldKey string

@@ -42,6 +43,12 @@ type JSONFormatter struct {

 	// }

 	FieldMap FieldMap

+	// CallerPrettyfier can be set by the user to modify the content

+	// of the function and file keys in the json data when ReportCaller is

+	// activated. If any of the returned value is the empty string the

+	// corresponding key will be removed from json fields.

+	CallerPrettyfier func(*runtime.Frame) (function string, file string)

+

 	// PrettyPrint will indent all json logs

 	PrettyPrint bool

 }

@@ -82,8 +89,17 @@ func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {

 	data[f.FieldMap.resolve(FieldKeyMsg)] = entry.Message

 	data[f.FieldMap.resolve(FieldKeyLevel)] = entry.Level.String()

 	if entry.HasCaller() {

-		data[f.FieldMap.resolve(FieldKeyFunc)] = entry.Caller.Function

-		data[f.FieldMap.resolve(FieldKeyFile)] = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)

+		funcVal := entry.Caller.Function

+		fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)

+		if f.CallerPrettyfier != nil {

+			funcVal, fileVal = f.CallerPrettyfier(entry.Caller)

+		}

+		if funcVal != "" {

+			data[f.FieldMap.resolve(FieldKeyFunc)] = funcVal

+		}

+		if fileVal != "" {

+			data[f.FieldMap.resolve(FieldKeyFile)] = fileVal

+		}

 	}

 	var b *bytes.Buffer

@@ -98,7 +114,7 @@ func (f *JSONFormatter) Format(entry *Entry) ([]byte, error) {

 		encoder.SetIndent("", "  ")

 	}

 	if err := encoder.Encode(data); err != nil {

-		return nil, fmt.Errorf("Failed to marshal fields to JSON, %v", err)

+		return nil, fmt.Errorf("failed to marshal fields to JSON, %v", err)

 	}

 	return b.Bytes(), nil

@@ -1,6 +1,7 @@

 package logrus

 import (

+	"context"

 	"io"

 	"os"

 	"sync"

@@ -124,6 +125,13 @@ func (logger *Logger) WithError(err error) *Entry {

 	return entry.WithError(err)

 }

+// Add a context to the log entry.

+func (logger *Logger) WithContext(ctx context.Context) *Entry {

+	entry := logger.newEntry()

+	defer logger.releaseEntry(entry)

+	return entry.WithContext(ctx)

+}

+

 // Overrides the time of the log entry.

 func (logger *Logger) WithTime(t time.Time) *Entry {

 	entry := logger.newEntry()

@@ -200,7 +208,7 @@ func (logger *Logger) Info(args ...interface{}) {

 func (logger *Logger) Print(args ...interface{}) {

 	entry := logger.newEntry()

-	entry.Info(args...)

+	entry.Print(args...)

 	logger.releaseEntry(entry)

 }

@@ -256,7 +264,7 @@ func (logger *Logger) Warnln(args ...interface{}) {

 }

 func (logger *Logger) Warningln(args ...interface{}) {

-	logger.Warn(args...)

+	logger.Warnln(args...)

 }

 func (logger *Logger) Errorln(args ...interface{}) {

@@ -74,7 +74,7 @@ func (level Level) MarshalText() ([]byte, error) {

 		return []byte("panic"), nil

 	}

-	return nil, fmt.Errorf("not a valid lorus level %q", level)

+	return nil, fmt.Errorf("not a valid logrus level %d", level)

 }

 // A constant exposing all logging levels

deleted file mode 100644

@@ -1,9 +0,0 @@

-// +build !appengine,!js,!windows,aix

-

-package logrus

-

-import "io"

-

-func checkIfTerminal(w io.Writer) bool {

-	return false

-}

new file mode 100644

@@ -0,0 +1,13 @@

+// +build darwin dragonfly freebsd netbsd openbsd

+

+package logrus

+

+import "golang.org/x/sys/unix"

+

+const ioctlReadTermios = unix.TIOCGETA

+

+func isTerminal(fd int) bool {

+	_, err := unix.IoctlGetTermios(fd, ioctlReadTermios)

+	return err == nil

+}

+

@@ -1,18 +1,16 @@

-// +build !appengine,!js,!windows,!aix

+// +build !appengine,!js,!windows

 package logrus

 import (

 	"io"

 	"os"

-

-	"golang.org/x/crypto/ssh/terminal"

 )

 func checkIfTerminal(w io.Writer) bool {

 	switch v := w.(type) {

 	case *os.File:

-		return terminal.IsTerminal(int(v.Fd()))

+		return isTerminal(int(v.Fd()))

 	default:

 		return false

 	}

new file mode 100644

@@ -0,0 +1,13 @@

+// +build linux aix

+

+package logrus

+

+import "golang.org/x/sys/unix"

+

+const ioctlReadTermios = unix.TCGETS

+

+func isTerminal(fd int) bool {

+	_, err := unix.IoctlGetTermios(fd, ioctlReadTermios)

+	return err == nil

+}

+

@@ -12,18 +12,13 @@ import (

 )

 const (

-	nocolor = 0

-	red     = 31

-	green   = 32

-	yellow  = 33

-	blue    = 36

-	gray    = 37

+	red    = 31

+	yellow = 33

+	blue   = 36

+	gray   = 37

 )

-var (

-	baseTimestamp time.Time

-	emptyFieldMap FieldMap

-)

+var baseTimestamp time.Time

 func init() {

 	baseTimestamp = time.Now()

@@ -77,6 +72,12 @@ type TextFormatter struct {

 	//         FieldKeyMsg:   "@message"}}

 	FieldMap FieldMap

+	// CallerPrettyfier can be set by the user to modify the content

+	// of the function and file keys in the data when ReportCaller is

+	// activated. If any of the returned value is the empty string the

+	// corresponding key will be removed from fields.

+	CallerPrettyfier func(*runtime.Frame) (function string, file string)

+

 	terminalInitOnce sync.Once

 }

@@ -118,6 +119,8 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {

 		keys = append(keys, k)

 	}

+	var funcVal, fileVal string

+

 	fixedKeys := make([]string, 0, 4+len(data))

 	if !f.DisableTimestamp {

 		fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyTime))

@@ -130,8 +133,19 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {

 		fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyLogrusError))

 	}

 	if entry.HasCaller() {

-		fixedKeys = append(fixedKeys,

-			f.FieldMap.resolve(FieldKeyFunc), f.FieldMap.resolve(FieldKeyFile))

+		if f.CallerPrettyfier != nil {

+			funcVal, fileVal = f.CallerPrettyfier(entry.Caller)

+		} else {

+			funcVal = entry.Caller.Function

+			fileVal = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)

+		}

+

+		if funcVal != "" {

+			fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFunc))

+		}

+		if fileVal != "" {

+			fixedKeys = append(fixedKeys, f.FieldMap.resolve(FieldKeyFile))

+		}

 	}

 	if !f.DisableSorting {

@@ -166,6 +180,7 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {

 	if f.isColored() {

 		f.printColored(b, entry, keys, data, timestampFormat)

 	} else {

+

 		for _, key := range fixedKeys {

 			var value interface{}

 			switch {

@@ -178,9 +193,9 @@ func (f *TextFormatter) Format(entry *Entry) ([]byte, error) {

 			case key == f.FieldMap.resolve(FieldKeyLogrusError):

 				value = entry.err

 			case key == f.FieldMap.resolve(FieldKeyFunc) && entry.HasCaller():

-				value = entry.Caller.Function

+				value = funcVal

 			case key == f.FieldMap.resolve(FieldKeyFile) && entry.HasCaller():

-				value = fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)

+				value = fileVal

 			default:

 				value = data[key]

 			}

@@ -215,10 +230,21 @@ func (f *TextFormatter) printColored(b *bytes.Buffer, entry *Entry, keys []strin

 	entry.Message = strings.TrimSuffix(entry.Message, "\n")

 	caller := ""

-

 	if entry.HasCaller() {

-		caller = fmt.Sprintf("%s:%d %s()",

-			entry.Caller.File, entry.Caller.Line, entry.Caller.Function)

+		funcVal := fmt.Sprintf("%s()", entry.Caller.Function)

+		fileVal := fmt.Sprintf("%s:%d", entry.Caller.File, entry.Caller.Line)

+

+		if f.CallerPrettyfier != nil {

+			funcVal, fileVal = f.CallerPrettyfier(entry.Caller)

+		}

+

+		if fileVal == "" {

+			caller = funcVal

+		} else if funcVal == "" {

+			caller = fileVal

+		} else {

+			caller = fileVal + " " + funcVal

+		}

 	}

 	if f.DisableTimestamp {

deleted file mode 100644

@@ -1,955 +0,0 @@

-// Copyright 2011 The Go Authors. All rights reserved.

-// Use of this source code is governed by a BSD-style

-// license that can be found in the LICENSE file.

-

-package terminal

-

-import (

-	"bytes"

-	"io"

-	"sync"

-	"unicode/utf8"

-)

-

-// EscapeCodes contains escape sequences that can be written to the terminal in

-// order to achieve different styles of text.

-type EscapeCodes struct {

-	// Foreground colors

-	Black, Red, Green, Yellow, Blue, Magenta, Cyan, White []byte

-

-	// Reset all attributes

-	Reset []byte

-}

-

-var vt100EscapeCodes = EscapeCodes{

-	Black:   []byte{keyEscape, '[', '3', '0', 'm'},

-	Red:     []byte{keyEscape, '[', '3', '1', 'm'},

-	Green:   []byte{keyEscape, '[', '3', '2', 'm'},

-	Yellow:  []byte{keyEscape, '[', '3', '3', 'm'},

-	Blue:    []byte{keyEscape, '[', '3', '4', 'm'},

-	Magenta: []byte{keyEscape, '[', '3', '5', 'm'},

-	Cyan:    []byte{keyEscape, '[', '3', '6', 'm'},

-	White:   []byte{keyEscape, '[', '3', '7', 'm'},

-

-	Reset: []byte{keyEscape, '[', '0', 'm'},

-}

-

-// Terminal contains the state for running a VT100 terminal that is capable of

-// reading lines of input.

-type Terminal struct {

-	// AutoCompleteCallback, if non-null, is called for each keypress with

-	// the full input line and the current position of the cursor (in

-	// bytes, as an index into |line|). If it returns ok=false, the key

-	// press is processed normally. Otherwise it returns a replacement line

-	// and the new cursor position.

-	AutoCompleteCallback func(line string, pos int, key rune) (newLine string, newPos int, ok bool)

-

-	// Escape contains a pointer to the escape codes for this terminal.

-	// It's always a valid pointer, although the escape codes themselves

-	// may be empty if the terminal doesn't support them.

-	Escape *EscapeCodes

-

-	// lock protects the terminal and the state in this object from

-	// concurrent processing of a key press and a Write() call.

-	lock sync.Mutex

-

-	c      io.ReadWriter

-	prompt []rune

-

-	// line is the current line being entered.

-	line []rune

-	// pos is the logical position of the cursor in line

-	pos int

-	// echo is true if local echo is enabled

-	echo bool

-	// pasteActive is true iff there is a bracketed paste operation in

-	// progress.

-	pasteActive bool

-

-	// cursorX contains the current X value of the cursor where the left

-	// edge is 0. cursorY contains the row number where the first row of

-	// the current line is 0.

-	cursorX, cursorY int

-	// maxLine is the greatest value of cursorY so far.

-	maxLine int

-

-	termWidth, termHeight int

-

-	// outBuf contains the terminal data to be sent.

-	outBuf []byte

-	// remainder contains the remainder of any partial key sequences after

-	// a read. It aliases into inBuf.

-	remainder []byte

-	inBuf     [256]byte

-

-	// history contains previously entered commands so that they can be

-	// accessed with the up and down keys.

-	history stRingBuffer

-	// historyIndex stores the currently accessed history entry, where zero

-	// means the immediately previous entry.

-	historyIndex int

-	// When navigating up and down the history it's possible to return to

-	// the incomplete, initial line. That value is stored in

-	// historyPending.

-	historyPending string

-}

-

-// NewTerminal runs a VT100 terminal on the given ReadWriter. If the ReadWriter is

-// a local terminal, that terminal must first have been put into raw mode.

-// prompt is a string that is written at the start of each input line (i.e.

-// "> ").

-func NewTerminal(c io.ReadWriter, prompt string) *Terminal {

-	return &Terminal{

-		Escape:       &vt100EscapeCodes,

-		c:            c,

-		prompt:       []rune(prompt),

-		termWidth:    80,

-		termHeight:   24,

-		echo:         true,

-		historyIndex: -1,

-	}

-}

-

-const (

-	keyCtrlD     = 4

-	keyCtrlU     = 21

-	keyEnter     = '\r'

-	keyEscape    = 27

-	keyBackspace = 127

-	keyUnknown   = 0xd800 /* UTF-16 surrogate area */ + iota

-	keyUp

-	keyDown

-	keyLeft

-	keyRight

-	keyAltLeft

-	keyAltRight

-	keyHome

-	keyEnd

-	keyDeleteWord

-	keyDeleteLine

-	keyClearScreen

-	keyPasteStart

-	keyPasteEnd

-)

-

-var (

-	crlf       = []byte{'\r', '\n'}

-	pasteStart = []byte{keyEscape, '[', '2', '0', '0', '~'}

-	pasteEnd   = []byte{keyEscape, '[', '2', '0', '1', '~'}

-)

-

-// bytesToKey tries to parse a key sequence from b. If successful, it returns

-// the key and the remainder of the input. Otherwise it returns utf8.RuneError.

-func bytesToKey(b []byte, pasteActive bool) (rune, []byte) {

-	if len(b) == 0 {

-		return utf8.RuneError, nil

-	}

-

-	if !pasteActive {

-		switch b[0] {

-		case 1: // ^A

-			return keyHome, b[1:]

-		case 5: // ^E

-			return keyEnd, b[1:]

-		case 8: // ^H

-			return keyBackspace, b[1:]

-		case 11: // ^K

-			return keyDeleteLine, b[1:]

-		case 12: // ^L

-			return keyClearScreen, b[1:]

-		case 23: // ^W

-			return keyDeleteWord, b[1:]

-		case 14: // ^N

-			return keyDown, b[1:]

-		case 16: // ^P

-			return keyUp, b[1:]

-		}

-	}

-

-	if b[0] != keyEscape {

-		if !utf8.FullRune(b) {

-			return utf8.RuneError, b

-		}

-		r, l := utf8.DecodeRune(b)

-		return r, b[l:]

-	}

-

-	if !pasteActive && len(b) >= 3 && b[0] == keyEscape && b[1] == '[' {

-		switch b[2] {

-		case 'A':

-			return keyUp, b[3:]

-		case 'B':

-			return keyDown, b[3:]

-		case 'C':

-			return keyRight, b[3:]

-		case 'D':

-			return keyLeft, b[3:]

-		case 'H':

-			return keyHome, b[3:]

-		case 'F':

-			return keyEnd, b[3:]

-		}

-	}

-

-	if !pasteActive && len(b) >= 6 && b[0] == keyEscape && b[1] == '[' && b[2] == '1' && b[3] == ';' && b[4] == '3' {

-		switch b[5] {

-		case 'C':

-			return keyAltRight, b[6:]

-		case 'D':

-			return keyAltLeft, b[6:]

-		}

-	}

-

-	if !pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteStart) {

-		return keyPasteStart, b[6:]

-	}

-

-	if pasteActive && len(b) >= 6 && bytes.Equal(b[:6], pasteEnd) {

-		return keyPasteEnd, b[6:]

-	}

-

-	// If we get here then we have a key that we don't recognise, or a

-	// partial sequence. It's not clear how one should find the end of a

-	// sequence without knowing them all, but it seems that [a-zA-Z~] only

-	// appears at the end of a sequence.

-	for i, c := range b[0:] {

-		if c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c == '~' {

-			return keyUnknown, b[i+1:]

-		}

-	}

-

-	return utf8.RuneError, b

-}

-

-// queue appends data to the end of t.outBuf

-func (t *Terminal) queue(data []rune) {

-	t.outBuf = append(t.outBuf, []byte(string(data))...)

-}

-

-var eraseUnderCursor = []rune{' ', keyEscape, '[', 'D'}

-var space = []rune{' '}

-

-func isPrintable(key rune) bool {

-	isInSurrogateArea := key >= 0xd800 && key <= 0xdbff

-	return key >= 32 && !isInSurrogateArea

-}

-

-// moveCursorToPos appends data to t.outBuf which will move the cursor to the

-// given, logical position in the text.

-func (t *Terminal) moveCursorToPos(pos int) {

-	if !t.echo {

-		return

-	}

-

-	x := visualLength(t.prompt) + pos

-	y := x / t.termWidth

-	x = x % t.termWidth

-

-	up := 0

-	if y < t.cursorY {

-		up = t.cursorY - y

-	}

-

-	down := 0

-	if y > t.cursorY {

-		down = y - t.cursorY

-	}

-

-	left := 0

-	if x < t.cursorX {

-		left = t.cursorX - x

-	}

-

-	right := 0

-	if x > t.cursorX {

-		right = x - t.cursorX

-	}

-

-	t.cursorX = x

-	t.cursorY = y

-	t.move(up, down, left, right)

-}

-

-func (t *Terminal) move(up, down, left, right int) {

-	movement := make([]rune, 3*(up+down+left+right))

-	m := movement

-	for i := 0; i < up; i++ {

-		m[0] = keyEscape

-		m[1] = '['

-		m[2] = 'A'

-		m = m[3:]

-	}

-	for i := 0; i < down; i++ {

-		m[0] = keyEscape

-		m[1] = '['

-		m[2] = 'B'

-		m = m[3:]

-	}

-	for i := 0; i < left; i++ {

-		m[0] = keyEscape

-		m[1] = '['

-		m[2] = 'D'

-		m = m[3:]

-	}

-	for i := 0; i < right; i++ {

-		m[0] = keyEscape

-		m[1] = '['

-		m[2] = 'C'

-		m = m[3:]

-	}

-

-	t.queue(movement)

-}

-

-func (t *Terminal) clearLineToRight() {

-	op := []rune{keyEscape, '[', 'K'}

-	t.queue(op)

-}

-

-const maxLineLength = 4096

-

-func (t *Terminal) setLine(newLine []rune, newPos int) {

-	if t.echo {

-		t.moveCursorToPos(0)

-		t.writeLine(newLine)

-		for i := len(newLine); i < len(t.line); i++ {

-			t.writeLine(space)

-		}

-		t.moveCursorToPos(newPos)

-	}

-	t.line = newLine

-	t.pos = newPos

-}

-

-func (t *Terminal) advanceCursor(places int) {

-	t.cursorX += places

-	t.cursorY += t.cursorX / t.termWidth

-	if t.cursorY > t.maxLine {

-		t.maxLine = t.cursorY

-	}

-	t.cursorX = t.cursorX % t.termWidth

-

-	if places > 0 && t.cursorX == 0 {

-		// Normally terminals will advance the current position

-		// when writing a character. But that doesn't happen

-		// for the last character in a line. However, when

-		// writing a character (except a new line) that causes

-		// a line wrap, the position will be advanced two

-		// places.

-		//

-		// So, if we are stopping at the end of a line, we

-		// need to write a newline so that our cursor can be

-		// advanced to the next line.

-		t.outBuf = append(t.outBuf, '\r', '\n')

-	}

-}

-

-func (t *Terminal) eraseNPreviousChars(n int) {

-	if n == 0 {

-		return

-	}

-

-	if t.pos < n {

-		n = t.pos

-	}

-	t.pos -= n

-	t.moveCursorToPos(t.pos)

-

-	copy(t.line[t.pos:], t.line[n+t.pos:])

-	t.line = t.line[:len(t.line)-n]

-	if t.echo {

-		t.writeLine(t.line[t.pos:])

-		for i := 0; i < n; i++ {

-			t.queue(space)

-		}

-		t.advanceCursor(n)

-		t.moveCursorToPos(t.pos)

-	}

-}

-

-// countToLeftWord returns then number of characters from the cursor to the

-// start of the previous word.

-func (t *Terminal) countToLeftWord() int {

-	if t.pos == 0 {

-		return 0

-	}

-

-	pos := t.pos - 1

-	for pos > 0 {

-		if t.line[pos] != ' ' {

-			break

-		}

-		pos--

-	}

-	for pos > 0 {

-		if t.line[pos] == ' ' {

-			pos++

-			break

-		}

-		pos--

-	}

-

-	return t.pos - pos

-}

-

-// countToRightWord returns then number of characters from the cursor to the

-// start of the next word.

-func (t *Terminal) countToRightWord() int {

-	pos := t.pos

-	for pos < len(t.line) {

-		if t.line[pos] == ' ' {

-			break

-		}

-		pos++

-	}

-	for pos < len(t.line) {

-		if t.line[pos] != ' ' {

-			break

-		}

-		pos++

-	}

-	return pos - t.pos

-}

-

-// visualLength returns the number of visible glyphs in s.

-func visualLength(runes []rune) int {

-	inEscapeSeq := false

-	length := 0

-

-	for _, r := range runes {

-		switch {

-		case inEscapeSeq:

-			if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {

-				inEscapeSeq = false

-			}

-		case r == '\x1b':

-			inEscapeSeq = true

-		default:

-			length++

-		}

-	}

-

-	return length

-}

-

-// handleKey processes the given key and, optionally, returns a line of text

-// that the user has entered.

-func (t *Terminal) handleKey(key rune) (line string, ok bool) {

-	if t.pasteActive && key != keyEnter {