handled leading and interposed zero ansi-arguments

Since its valid ANSI to have a in other arguments embedded zero:
"\xB1[31;0;33m" we have to transform this into a end sequence and
a new sequence for restarting after linebreak.
All the while we have to ignore leading zeros, so that:
"\xB1[0100m" does not become "\xB1[0m\x1B100m".

After talking with muesli: Ignoring Write errors explicitly, maybe to be
changed in the future.

Author: treilik

wordwrap/wordwrap.go

@@ -23,18 +23,23 @@ type WordWrap struct {
 	Newline        []rune
 	KeepNewlines   bool
 	HardWrap       bool
-	TabReplace     string // since tabs can have differrent lengths, replace them with this when hardwrap is enabled
+	TabReplace     string // since tabs can have different lengths, replace them with this when hardwrap is enabled
 	PreserveSpaces bool
 
 	buf   bytes.Buffer // processed and, in line, accepted bytes
 	space bytes.Buffer // pending continues spaces bytes
 	word  ansi.Buffer  // pending continues word bytes
 
-	lineLen int // the visible length of the line not accorat for tabs
+	lineLen int // the visible length of the line not accurate for tabs
 	ansi    bool
 
-	wroteBegin bool         // mark is since the last newline something has writen to the buffer (for ansi restart)
+	wroteBegin bool         // mark is since the last newline something has written to the buffer (for ansi restart)
 	lastAnsi   bytes.Buffer // hold last active ansi sequence
+
+	// the following are used to remove leading zeros from the single arguments of the ansi-sequence, but still detect single zeros:
+	// \x1B[0031;0000m => \x1B[31;0m
+	newArgument bool
+	leadingZero bool
 }
 
 // NewWriter returns a new instance of a word-wrapping writer, initialized with
@@ -64,8 +69,8 @@ func String(s string, limit int) string {
 	return string(Bytes([]byte(s), limit))
 }
 
-// HardWrap is a shorthand for declaring a new hardwraping WordWrap instance,
-// since varibale length characters can not be hard wraped to a fixed length,
+// HardWrap is a shorthand for declaring a new hardwrapping WordWrap instance,
+// since variable length characters can not be hard wrapped to a fixed length,
 // tabs will be replaced by TabReplace, use according amount of spaces.
 func HardWrap(s string, limit int, tabReplace string) string {
 	f := NewWriter(limit)
@@ -77,22 +82,22 @@ func HardWrap(s string, limit int, tabReplace string) string {
 	return f.String()
 }
 
-// addes pending spaces to the buf(fer) and then resets the space buffer.
+// adds pending spaces to the buf(fer) and then resets the space buffer.
 func (w *WordWrap) addSpace() {
 	if w.space.Len() <= w.Limit-w.lineLen {
 		w.lineLen += w.space.Len()
-		w.buf.Write(w.space.Bytes())
+		_, _ = w.buf.Write(w.space.Bytes())
 	} else {
 		length := w.space.Len()
 		first := w.Limit - w.lineLen
-		w.buf.WriteString(strings.Repeat(" ", first))
+		_, _ = w.buf.WriteString(strings.Repeat(" ", first))
 		length -= first
 		for length >= w.Limit {
-			w.buf.WriteString("\n" + strings.Repeat(" ", w.Limit))
+			_, _ = w.buf.WriteString("\n" + strings.Repeat(" ", w.Limit))
 			length -= w.Limit
 		}
 		if length > 0 {
-			w.buf.WriteString("\n" + strings.Repeat(" ", length))
+			_, _ = w.buf.WriteString("\n" + strings.Repeat(" ", length))
 		}
 		w.lineLen = length
 	}
@@ -113,10 +118,10 @@ func (w *WordWrap) addNewLine() {
 		w.addSpace()
 	}
 	if w.lastAnsi.Len() != 0 {
-		// end ansi befor linebreak
-		w.buf.WriteString("\x1b[0m")
+		// end ansi before linebreak
+		_, _ = w.buf.WriteString("\x1B[0m")
 	}
-	w.buf.WriteRune('\n')
+	_, _ = w.buf.WriteRune('\n')
 	w.lineLen = 0
 	w.space.Reset()
 	w.wroteBegin = false
@@ -149,25 +154,60 @@ func (w *WordWrap) Write(b []byte) (int, error) {
 	for _, c := range s {
 		// Restart Ansi after line break if there is more text
 		if !w.wroteBegin && !w.ansi && w.lastAnsi.Len() != 0 {
-			w.buf.Write(w.lastAnsi.Bytes())
+			_, _ = w.buf.Write(w.lastAnsi.Bytes())
 			w.addWord()
 		}
 		w.wroteBegin = true
 		if c == '\x1B' {
 			// ANSI escape sequence
-			w.word.WriteRune(c)
-			w.lastAnsi.WriteRune(c)
+			_, _ = w.word.WriteRune(c)
+			_, _ = w.lastAnsi.WriteRune(c)
 			w.ansi = true
+			w.newArgument = true
 		} else if w.ansi {
-			w.word.WriteRune(c)
-			w.lastAnsi.WriteRune(c)
+
+			// ignore leading zeros but remember single ones.
+			if c == '0' && w.newArgument {
+				w.leadingZero = true
+				continue
+			}
+			w.newArgument = false
+			// if a digit other then zero is encountered reset leading zero since we can ignore the leading zeroes if there where any.
+			if inGroup([]rune{'1', '2', '3', '4', '5', '6', '7', '8', '9'}, c) {
+				w.leadingZero = false
+			}
+
+			// check if new ANSI-argument starts
+			if inGroup([]rune{'[', ';'}, c) {
+				w.newArgument = true
+				// if w.leadingZero is here, we know that its a valid zero => reset and restart sequence.
+				if w.leadingZero {
+					// since we are still in the middle of the sequence and have reset the last ansi, we have to restart a new sequence:
+					w.lastAnsi.Reset()
+					_, _ = w.lastAnsi.WriteString("\x1B[")
+					w.leadingZero = false
+					_, _ = w.word.WriteString("0m\x1B[")
+					// "\x1B[31;0;32m" => "\x1B[31;0m\x1B[32m"
+					continue // dont write "replace" semicolon
+				}
+			}
+
+			_, _ = w.lastAnsi.WriteRune(c)
+
 			if (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) {
+				// dont restart lastAnsi since its a end of a sequence. (not in the middle of one)
+				if w.leadingZero {
+					_, _ = w.word.WriteRune('0')
+
+					w.lastAnsi.Reset()
+					w.leadingZero = false
+				}
 				// ANSI sequence terminated
 				w.ansi = false
 			}
-			if c == 'm' && strings.HasSuffix(w.lastAnsi.String(), "\x1b[0m") {
-				w.lastAnsi.Reset()
-			}
+
+			_, _ = w.word.WriteRune(c)
+
 		} else if inGroup(w.Newline, c) {
 			// end of current line
 			// see if we can add the content of the space buffer to the current line
@@ -191,10 +231,10 @@ func (w *WordWrap) Write(b []byte) (int, error) {
 			// valid breakpoint
 			w.addSpace()
 			w.addWord()
-			w.buf.WriteRune(c)
+			_, _ = w.buf.WriteRune(c)
 		} else if w.HardWrap && w.lineLen+w.word.PrintableRuneWidth()+runewidth.RuneWidth(c)+w.space.Len() == w.Limit {
-			// Word is at the limite -> begin new word
-			w.word.WriteRune(c)
+			// Word is at the limit -> begin new word
+			_, _ = w.word.WriteRune(c)
 			w.addWord()
 		} else {
 			// any other character
@@ -224,13 +264,13 @@ func (w *WordWrap) Close() error {
 }
 
 // Bytes returns the word-wrapped result as a byte slice.
-// Make sure to have closed the worwrapper, befor calling it.
+// Make sure to have closed the wordwrapper, before calling it.
 func (w *WordWrap) Bytes() []byte {
 	return w.buf.Bytes()
 }
 
 // String returns the word-wrapped result as a string.
-// Make sure to have closed the worwrapper, befor calling it.
+// Make sure to have closed the wordwrapper, before calling it.
 func (w *WordWrap) String() string {
 	return w.buf.String()
 }

wordwrap/wordwrap_test.go

@@ -250,6 +250,24 @@ func TestHardWrap(t *testing.T) {
 			true,
 			"",
 		},
+		// check if befor zero gets reset and after gets remembered/repeated
+		{
+			"\x1b[34mblue\x1b[33;0;31mred\x1b[0m",
+			"\x1b[34mblue\x1b[33;0m\x1b[31mre\x1b[0m\n\x1b[31md\x1b[0m",
+			6,
+			true,
+			true,
+			"",
+		},
+		// check squash multiple zeros into one and ignore leading zeros
+		{
+			"\x1b[034mblue\x1b[33;00000000000000000000;000000000000031mred\x1b[0m",
+			"\x1b[34mblue\x1b[33;0m\x1b[31mre\x1b[0m\n\x1b[31md\x1b[0m",
+			6,
+			true,
+			true,
+			"",
+		},
 	}
 	for i, tc := range tt {
 		f := NewWriter(tc.Limit)