Implemented Hardwrap - but not working yet

Author: treilik

wordwrap/wordwrap.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 	"unicode"
 
+	runewidth "github.com/mattn/go-runewidth"
 	"github.com/muesli/reflow/ansi"
 )
 
@@ -21,13 +22,17 @@ type WordWrap struct {
 	Breakpoints  []rune
 	Newline      []rune
 	KeepNewlines bool
+	HardBreak    bool
 
-	buf   bytes.Buffer
-	space bytes.Buffer
-	word  ansi.Buffer
+	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
-	ansi    bool
+	hardWriter ansi.Writer
+
+	lineLen  int
+	ansi     bool
+	lastAnsi bytes.Buffer
 }
 
 // NewWriter returns a new instance of a word-wrapping writer, initialized with
@@ -57,6 +62,7 @@ func String(s string, limit int) string {
 	return string(Bytes([]byte(s), limit))
 }
 
+// addes pending spaces to the buf(fer) ... and resets the space buffer
 func (w *WordWrap) addSpace() {
 	w.lineLen += w.space.Len()
 	_, _ = w.buf.Write(w.space.Bytes())
@@ -73,7 +79,11 @@ func (w *WordWrap) addWord() {
 }
 
 func (w *WordWrap) addNewLine() {
-	_, _ = w.buf.WriteRune('\n')
+	if w.lastAnsi.Len() != 0 {
+		// end ansi befor linebreak
+		w.buf.WriteString("\x1b[0m")
+	}
+	w.buf.WriteRune('\n')
 	w.lineLen = 0
 	w.space.Reset()
 }
@@ -99,16 +109,26 @@ func (w *WordWrap) Write(b []byte) (int, error) {
 	}
 
 	for _, c := range s {
+		// Restart Ansi after line break if there is more text
+		if w.lineLen == 0 && w.buf.Len() == 0 && w.lastAnsi.Len() != 0 {
+			w.buf.Write(w.lastAnsi.Bytes())
+			w.addWord()
+		}
 		if c == '\x1B' {
 			// ANSI escape sequence
-			_, _ = w.word.WriteRune(c)
+			w.word.WriteRune(c)
+			w.lastAnsi.WriteRune(c)
 			w.ansi = true
 		} else if w.ansi {
-			_, _ = w.word.WriteRune(c)
+			w.word.WriteRune(c)
+			w.lastAnsi.WriteRune(c)
 			if (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) {
 				// ANSI sequence terminated
 				w.ansi = false
 			}
+			if w.lastAnsi.String() == "\x1b[0m" {
+				w.lastAnsi.Reset()
+			}
 		} 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
@@ -132,7 +152,12 @@ 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.HardBreak && w.lineLen+runewidth.RuneWidth(c) > w.Limit {
+			// Word excends the limite -> break and begin new line/word
+			w.addWord()
+			w.addNewLine()
+			w.buf.WriteRune(c)
 		} else {
 			// any other character
 			_, _ = w.word.WriteRune(c)
@@ -157,11 +182,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
 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
 func (w *WordWrap) String() string {
 	return w.buf.String()
 }

wordwrap/wordwrap_test.go

@@ -10,20 +10,23 @@ func TestWordWrap(t *testing.T) {
 		Expected     string
 		Limit        int
 		KeepNewlines bool
+		HardWrap     bool
 	}{
 		// No-op, should pass through, including trailing whitespace:
 		{
 			"foobar\n ",
 			"foobar\n ",
 			0,
 			true,
+			false,
 		},
 		// Nothing to wrap here, should pass through:
 		{
 			"foo",
 			"foo",
 			4,
 			true,
+			false,
 		},
 		// A single word that is too long passes through.
 		// We do not break long words:
@@ -32,27 +35,31 @@ func TestWordWrap(t *testing.T) {
 			"foobarfoo",
 			4,
 			true,
+			false,
 		},
 		// Lines are broken at whitespace:
 		{
 			"foo bar foo",
 			"foo\nbar\nfoo",
 			4,
 			true,
+			false,
 		},
 		// A hyphen is a valid breakpoint:
 		{
 			"foo-foobar",
 			"foo-\nfoobar",
 			4,
 			true,
+			false,
 		},
 		// Space buffer needs to be emptied before breakpoints:
 		{
 			"foo --bar",
 			"foo --bar",
 			9,
 			true,
+			false,
 		},
 		// Lines are broken at whitespace, even if words
 		// are too long. We do not break words:
@@ -61,13 +68,15 @@ func TestWordWrap(t *testing.T) {
 			"foo\nbars\nfoobars",
 			4,
 			true,
+			false,
 		},
 		// A word that would run beyond the limit is wrapped:
 		{
 			"foo bar",
 			"foo\nbar",
 			5,
 			true,
+			false,
 		},
 		// Whitespace that trails a line and fits the width
 		// passes through, as does whitespace prefixing an
@@ -77,6 +86,7 @@ func TestWordWrap(t *testing.T) {
 			"foo\nb\t a\n bar",
 			4,
 			true,
+			false,
 		},
 		// Trailing whitespace is removed if it doesn't fit the width.
 		// Runs of whitespace on which a line is broken are removed:
@@ -85,53 +95,61 @@ func TestWordWrap(t *testing.T) {
 			"foo\nb\nar",
 			4,
 			true,
+			false,
 		},
 		// An explicit line break at the end of the input is preserved:
 		{
 			"foo bar foo\n",
 			"foo\nbar\nfoo\n",
 			4,
 			true,
+			false,
 		},
 		// Explicit break are always preserved:
 		{
 			"\nfoo bar\n\n\nfoo\n",
 			"\nfoo\nbar\n\n\nfoo\n",
 			4,
 			true,
+			false,
 		},
 		// Unless we ask them to be ignored:
 		{
 			"\nfoo bar\n\n\nfoo\n",
 			"foo\nbar\nfoo",
 			4,
 			false,
+			false,
 		},
 		// Complete example:
 		{
 			" This is a list: \n\n\t* foo\n\t* bar\n\n\n\t* foo  \nbar    ",
 			" This\nis a\nlist: \n\n\t* foo\n\t* bar\n\n\n\t* foo\nbar",
 			6,
 			true,
+			false,
 		},
 		// ANSI sequence codes don't affect length calculation:
 		{
 			"\x1B[38;2;249;38;114mfoo\x1B[0m\x1B[38;2;248;248;242m \x1B[0m\x1B[38;2;230;219;116mbar\x1B[0m",
 			"\x1B[38;2;249;38;114mfoo\x1B[0m\x1B[38;2;248;248;242m \x1B[0m\x1B[38;2;230;219;116mbar\x1B[0m",
 			7,
 			true,
+			false,
 		},
 		// ANSI control codes don't get wrapped, but get finished and again started at each line break:
 		{
 			"\x1B[38;2;249;38;114m(\x1B[0m\x1B[38;2;248;248;242mjust another test\x1B[38;2;249;38;114m)\x1B[0m",
-			"\x1B[38;2;249;38;114m(\x1B[0m\x1B[38;2;248;248;242mjust\x1B[0m\n\x1B[38;2;248;248;242manother\x1B[0m\x1B[0m\n\x1B[38;2;248;248;242mtest\x1B[38;2;249;38;114m)\x1B[0m",
+			"\x1B[38;2;249;38;114m(\x1B[0m\x1B[38;2;248;248;242mjust\x1B[0m\n\x1B[38;2;248;248;242manother\x1B[0m\n\x1B[38;2;248;248;242mtest\x1B[38;2;249;38;114m)\x1B[0m",
 			3,
 			true,
+			false,
 		},
 	}
 
 	for i, tc := range tt {
 		f := NewWriter(tc.Limit)
+		f.HardBreak = tc.HardWrap
 		f.KeepNewlines = tc.KeepNewlines
 
 		_, err := f.Write([]byte(tc.Input))