added PreserveSpaces and TabReplace to struct

for better managing char-preserving and hardwrap

Author: Kilian Drechsler

wordwrap/wordwrap.go

@@ -18,22 +18,23 @@ var (
 // support for ANSI escape sequences. This means you can style your terminal
 // output without affecting the word wrapping algorithm.
 type WordWrap struct {
-	Limit        int
-	Breakpoints  []rune
-	Newline      []rune
-	KeepNewlines bool
-	HardBreak    bool
-
-	buf   bytes.Buffer // processed and in line accepted bytes
+	Limit          int
+	Breakpoints    []rune
+	Newline        []rune
+	KeepNewlines   bool
+	HardWrap       bool
+	TabReplace     string // since tabs can have differrent lenghts, 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
 
-	hardWriter ansi.Writer
+	lineLen int // the visible lenght of the line not accorat for tabs
+	ansi    bool
 
-	wroteBegin bool
-	lineLen    int
-	ansi       bool
-	lastAnsi   bytes.Buffer
+	wroteBegin bool         // mark is since the last newline something has writen to the buffer (for ansi restart)
+	lastAnsi   bytes.Buffer // hold last active ansi sequence
 }
 
 // NewWriter returns a new instance of a word-wrapping writer, initialized with
@@ -63,10 +64,38 @@ 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 lenght characters can not be hard wraped to a fixed lenght,
+// tabs will be replaced by TabReplace, use according amount of spaces.
+func HardWrap(s string, limit int, tabReplace string) string {
+	f := NewWriter(limit)
+	f.HardWrap = true
+	f.TabReplace = tabReplace
+	_, _ = f.Write([]byte(s))
+	f.Close()
+
+	return f.String()
+}
+
 // 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())
+	if w.space.Len() <= w.Limit-w.lineLen {
+		w.lineLen += w.space.Len()
+		w.buf.Write(w.space.Bytes())
+	} else {
+		lenght := w.space.Len()
+		first := w.Limit - w.lineLen
+		w.buf.WriteString(strings.Repeat(" ", first))
+		lenght -= first
+		for lenght >= w.Limit {
+			w.buf.WriteString("\n" + strings.Repeat(" ", w.Limit))
+			lenght -= w.Limit
+		}
+		if lenght > 0 {
+			w.buf.WriteString("\n" + strings.Repeat(" ", lenght))
+		}
+		w.lineLen = lenght
+	}
 	w.space.Reset()
 }
 
@@ -80,6 +109,9 @@ func (w *WordWrap) addWord() {
 }
 
 func (w *WordWrap) addNewLine() {
+	if w.PreserveSpaces {
+		w.addSpace()
+	}
 	if w.lastAnsi.Len() != 0 {
 		// end ansi befor linebreak
 		w.buf.WriteString("\x1b[0m")
@@ -110,6 +142,10 @@ func (w *WordWrap) Write(b []byte) (int, error) {
 		s = strings.Replace(strings.TrimSpace(s), "\n", " ", -1)
 	}
 
+	if w.HardWrap {
+		s = strings.ReplaceAll(s, "\t", w.TabReplace)
+	}
+
 	for _, c := range s {
 		// Restart Ansi after line break if there is more text
 		if !w.wroteBegin && !w.ansi && w.lastAnsi.Len() != 0 {
@@ -156,11 +192,10 @@ func (w *WordWrap) Write(b []byte) (int, error) {
 			w.addSpace()
 			w.addWord()
 			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
+		} 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)
 			w.addWord()
-			w.addNewLine()
-			w.buf.WriteRune(c)
 		} else {
 			// any other character
 			_, _ = w.word.WriteRune(c)
@@ -180,7 +215,14 @@ func (w *WordWrap) Write(b []byte) (int, error) {
 // Close will finish the word-wrap operation. Always call it before trying to
 // retrieve the final result.
 func (w *WordWrap) Close() error {
+	if w.HardWrap && w.word.PrintableRuneWidth()+w.lineLen > w.Limit {
+		w.addNewLine()
+	}
+	if w.PreserveSpaces {
+		w.addSpace()
+	}
 	w.addWord()
+
 	return nil
 }
 

wordwrap/wordwrap_test.go

@@ -10,23 +10,20 @@ 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:
@@ -35,31 +32,27 @@ 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:
@@ -68,15 +61,13 @@ 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
@@ -86,7 +77,6 @@ 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:
@@ -95,61 +85,53 @@ 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\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))
@@ -171,3 +153,107 @@ func TestWordWrapString(t *testing.T) {
 		t.Errorf("expected:\n\n`%s`\n\nActual Output:\n\n`%s`", expected, actual)
 	}
 }
+
+func TestHardWrap(t *testing.T) {
+	tt := []struct {
+		Input          string
+		Expected       string
+		Limit          int
+		KeepNewlines   bool
+		PreserveSpaces bool
+		TabReplace     string
+	}{
+		// hardwrap wraps at limit and does not add newline if there is not more text
+		{
+			"foobarfoobar",
+			"foo\nbar\nfoo\nbar",
+			3,
+			true,
+			true,
+			"",
+		},
+		// With no TabReplace string tabs get ignored
+		{
+			"\tfoo\tbar\tfoo\tbar",
+			"foo\nbar\nfoo\nbar",
+			3,
+			true,
+			true,
+			"",
+		},
+		// limit of zero gets ignored
+		{
+			"foobar",
+			"foobar",
+			0,
+			true,
+			true,
+			"",
+		},
+		// ANSI gets ended and restarted at each linebreak, so that the ansi is self contained within a line.
+		{
+			"\x1B[38;2;249;38;114m(\x1B[0m\x1B[38;2;248;248;242mjust an\nother test\x1B[38;2;249;38;114m)\x1B[0m",
+			`(ju
+st 
+an
+oth
+er 
+tes
+t)`,
+			3,
+			true,
+			true,
+			"",
+		},
+		// if requested spaces are preserved as are Explicit linebreaks:
+		{
+			"\nfoo bar\n\n\nfoo\n",
+			"\nfoo \nbar\n\n\nfoo\n",
+			4,
+			true,
+			true,
+			"",
+		},
+		// Unless we ask them to be ignored:
+		{
+			"\nfoo bar\n\n\nfoo\n",
+			"foo\nbar\nfoo",
+			4,
+			false,
+			false,
+			"",
+		},
+		{
+			"test",
+			"test",
+			4,
+			true,
+			true,
+			"",
+		},
+		{
+			"                                        ",
+			"    \n    \n    \n    \n    \n    \n    \n    \n    \n    ",
+			4,
+			true,
+			true,
+			"",
+		},
+	}
+	for i, tc := range tt {
+		f := NewWriter(tc.Limit)
+		f.KeepNewlines = tc.KeepNewlines
+		f.HardWrap = true
+		f.PreserveSpaces = tc.PreserveSpaces
+
+		_, err := f.Write([]byte(tc.Input))
+		if err != nil {
+			t.Error(err)
+		}
+		f.Close()
+
+		if f.String() != tc.Expected {
+			t.Errorf("Test %d, expected:\n\n`%s`\n\nActual Output:\n\n`%s`", i, tc.Expected, f.String())
+		}
+	}
+}