package text import ( "github.com/mattn/go-runewidth" "strings" "unicode/utf8" ) // Wrap a text for an exact line size // Handle properly terminal color escape code func Wrap(text string, lineWidth int) (string, int) { return WrapLeftPadded(text, lineWidth, 0) } // Wrap a text for an exact line size with a left padding // Handle properly terminal color escape code func WrapLeftPadded(text string, lineWidth int, leftPad int) (string, int) { var lines []string nbLine := 0 pad := strings.Repeat(" ", leftPad) // tabs are formatted as 4 spaces text = strings.Replace(text, "\t", " ", -1) // NOTE: text is first segmented into lines so that softwrapLine can handle. for _, line := range strings.Split(text, "\n") { if line == "" || strings.TrimSpace(line) == "" { lines = append(lines, "") nbLine++ } else { wrapped := softwrapLine(line, lineWidth-leftPad) firstLine := true for _, seg := range strings.Split(wrapped, "\n") { if firstLine { lines = append(lines, pad+strings.TrimRight(seg, " ")) firstLine = false } else { lines = append(lines, pad+strings.TrimSpace(seg)) } nbLine++ } } } return strings.Join(lines, "\n"), nbLine } // Break a line into several lines so that each line consumes at most // 'textWidth' cells. Lines break at groups of white spaces and multibyte // chars. Nothing is removed from the original text so that it behaves like a // softwrap. // // Required: The line shall not contain '\n' // // WRAPPING ALGORITHM: The line is broken into non-breakable chunks, then line // breaks ("\n") are inserted between these groups so that the total length // between breaks does not exceed the required width. Words that are longer than // the textWidth are broen into pieces no longer than textWidth. // func softwrapLine(line string, textWidth int) string { // NOTE: terminal escapes are stripped out of the line so the algorithm is // simpler. Do not try to mix them in the wrapping algorithm, as it can get // complicated quickly. line1, termEscapes := extractTermEscapes(line) chunks := segmentLine(line1) // Reverse the chunk array so we can use it as a stack. for i, j := 0, len(chunks)-1; i < j; i, j = i+1, j-1 { chunks[i], chunks[j] = chunks[j], chunks[i] } var line2 string = "" var width int = 0 for len(chunks) > 0 { thisWord := chunks[len(chunks)-1] wl := wordLen(thisWord) if width+wl <= textWidth { line2 += chunks[len(chunks)-1] chunks = chunks[:len(chunks)-1] width += wl if width == textWidth && len(chunks) > 0 { // NOTE: new line begins when current line is full and there are more // chunks to come. line2 += "\n" width = 0 } } else if wl > textWidth { left, right := splitWord(chunks[len(chunks)-1], textWidth) line2 += left + "\n" chunks[len(chunks)-1] = right width = 0 } else { line2 += "\n" width = 0 } } line3 := applyTermEscapes(line2, termEscapes) return line3 } // EscapeItem: Storage of terminal escapes in a line. 'item' is the actural // escape command, and 'pos' is the index in the rune array where the 'item' // shall be inserted back. For example, the escape item in "F\x1b33mox" is // {"\x1b33m", 1}. type EscapeItem struct { item string pos int } // Extract terminal escapes out of a line, returns a new line without terminal // escapes and a slice of escape items. The terminal escapes can be inserted // back into the new line at rune index 'item.pos' to recover the original line. // // Required: The line shall not contain "\n" // func extractTermEscapes(line string) (string, []EscapeItem) { var termEscapes []EscapeItem var line1 string pos := 0 item := "" occupiedRuneCount := 0 inEscape := false for i, r := range []rune(line) { if r == '\x1b' { pos = i item = string(r) inEscape = true continue } if inEscape { item += string(r) if r == 'm' { termEscapes = append(termEscapes, EscapeItem{item, pos - occupiedRuneCount}) occupiedRuneCount += utf8.RuneCountInString(item) inEscape = false } continue } line1 += string(r) } return line1, termEscapes } // Apply the extracted terminal escapes to the edited line. The only edit // allowed is to insert "\n" like that in softwrapLine. Callers shall ensure // this since this function is not able to check it. func applyTermEscapes(line string, escapes []EscapeItem) string { if len(escapes) == 0 { return line } var out string = "" currPos := 0 currItem := 0 for _, r := range line { if currItem < len(escapes) && currPos == escapes[currItem].pos { // NOTE: We avoid terminal escapes at the end of a line by move them one // pass the end of line, so that algorithms who trim right spaces are // happy. But algorithms who trim left spaces are still unhappy. if r == '\n' { out += "\n" + escapes[currItem].item } else { out += escapes[currItem].item + string(r) currPos++ } currItem++ } else { if r != '\n' { currPos++ } out += string(r) } } return out } // Segment a line into chunks, where each chunk consists of chars with the same // type and is not breakable. func segmentLine(s string) []string { var chunks []string var word string wordType := NONE flushWord := func() { chunks = append(chunks, word) word = "" wordType = NONE } for _, r := range s { // A WIDE_CHAR itself constitutes a chunk. thisType := runeType(r) if thisType == WIDE_CHAR { if wordType != NONE { flushWord() } chunks = append(chunks, string(r)) continue } // Other type of chunks starts with a char of that type, and ends with a // char with different type or end of string. if thisType != wordType { if wordType != NONE { flushWord() } word = string(r) wordType = thisType } else { word += string(r) } } if word != "" { flushWord() } return chunks } // Rune categories // // These categories are so defined that each category forms a non-breakable // chunk. It IS NOT the same as unicode code point categories. // const ( NONE = -1 WIDE_CHAR = iota INVISIBLE = iota SHORT_UNICODE = iota SPACE = iota VISIBLE_ASCII = iota ) // Determine the category of a rune. func runeType(r rune) int { rw := runewidth.RuneWidth(r) if rw > 1 { return WIDE_CHAR } else if rw == 0 { return INVISIBLE } else if r > 127 { return SHORT_UNICODE } else if r == ' ' { return SPACE } else { return VISIBLE_ASCII } } // wordLen return the length of a word, while ignoring the terminal escape // sequences func wordLen(word string) int { length := 0 escape := false for _, char := range word { if char == '\x1b' { escape = true } if !escape { length += runewidth.RuneWidth(rune(char)) } if char == 'm' { escape = false } } return length } // splitWord split a word at the given length, while ignoring the terminal escape sequences func splitWord(word string, length int) (string, string) { runes := []rune(word) var result []rune added := 0 escape := false if length == 0 { return "", word } for _, r := range runes { if r == '\x1b' { escape = true } width := runewidth.RuneWidth(r) if width+added > length { // wide character made the length overflow break } result = append(result, r) if !escape { added += width if added >= length { break } } if r == 'm' { escape = false } } leftover := runes[len(result):] return string(result), string(leftover) } func minInt(a, b int) int { if a > b { return b } return a }