Use glamour and termev to render/colorize content (#181)

Merge branch 'master' into use-glamour

select Glamour Theme based on BackgroundColor

Merge branch 'master' into use-glamour

Merge branch 'master' into use-glamour

update termev

update go.mod

label color colorate

use glamour for issue content

Vendor: Add glamour

Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-authored-by: 6543 <6543@obermui.de>
Reviewed-on: https://gitea.com/gitea/tea/pulls/181
Reviewed-by: techknowlogick <techknowlogick@gitea.io>
Reviewed-by: Lunny Xiao <xiaolunwen@gmail.com>

vendor/github.com/muesli/reflow/wordwrap/wordwrap.go

@@ -0,0 +1,167 @@
+package wordwrap
+
+import (
+	"bytes"
+	"strings"
+	"unicode"
+
+	"github.com/muesli/reflow/ansi"
+)
+
+var (
+	defaultBreakpoints = []rune{'-'}
+	defaultNewline     = []rune{'\n'}
+)
+
+// WordWrap contains settings and state for customisable text reflowing with
+// 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
+
+	buf   bytes.Buffer
+	space bytes.Buffer
+	word  ansi.Buffer
+
+	lineLen int
+	ansi    bool
+}
+
+// NewWriter returns a new instance of a word-wrapping writer, initialized with
+// default settings.
+func NewWriter(limit int) *WordWrap {
+	return &WordWrap{
+		Limit:        limit,
+		Breakpoints:  defaultBreakpoints,
+		Newline:      defaultNewline,
+		KeepNewlines: true,
+	}
+}
+
+// Bytes is shorthand for declaring a new default WordWrap instance,
+// used to immediately word-wrap a byte slice.
+func Bytes(b []byte, limit int) []byte {
+	f := NewWriter(limit)
+	_, _ = f.Write(b)
+	f.Close()
+
+	return f.Bytes()
+}
+
+// String is shorthand for declaring a new default WordWrap instance,
+// used to immediately word-wrap a string.
+func String(s string, limit int) string {
+	return string(Bytes([]byte(s), limit))
+}
+
+func (w *WordWrap) addSpace() {
+	w.lineLen += w.space.Len()
+	w.buf.Write(w.space.Bytes())
+	w.space.Reset()
+}
+
+func (w *WordWrap) addWord() {
+	if w.word.Len() > 0 {
+		w.addSpace()
+		w.lineLen += w.word.PrintableRuneCount()
+		w.buf.Write(w.word.Bytes())
+		w.word.Reset()
+	}
+}
+
+func (w *WordWrap) addNewLine() {
+	w.buf.WriteRune('\n')
+	w.lineLen = 0
+	w.space.Reset()
+}
+
+func inGroup(a []rune, c rune) bool {
+	for _, v := range a {
+		if v == c {
+			return true
+		}
+	}
+	return false
+}
+
+// Write is used to write more content to the word-wrap buffer.
+func (w *WordWrap) Write(b []byte) (int, error) {
+	if w.Limit == 0 {
+		return w.buf.Write(b)
+	}
+
+	s := string(b)
+	if !w.KeepNewlines {
+		s = strings.Replace(strings.TrimSpace(s), "\n", " ", -1)
+	}
+
+	for _, c := range s {
+		if c == '\x1B' {
+			// ANSI escape sequence
+			w.word.WriteRune(c)
+			w.ansi = true
+		} else if w.ansi {
+			w.word.WriteRune(c)
+			if (c >= 0x40 && c <= 0x5a) || (c >= 0x61 && c <= 0x7a) {
+				// ANSI sequence terminated
+				w.ansi = false
+			}
+		} 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
+			if w.word.Len() == 0 {
+				if w.lineLen+w.space.Len() > w.Limit {
+					w.lineLen = 0
+				} else {
+					// preserve whitespace
+					w.buf.Write(w.space.Bytes())
+				}
+				w.space.Reset()
+			}
+
+			w.addWord()
+			w.addNewLine()
+		} else if unicode.IsSpace(c) {
+			// end of current word
+			w.addWord()
+			w.space.WriteRune(c)
+		} else if inGroup(w.Breakpoints, c) {
+			// valid breakpoint
+			w.addSpace()
+			w.addWord()
+			w.buf.WriteRune(c)
+		} else {
+			// any other character
+			w.word.WriteRune(c)
+
+			// add a line break if the current word would exceed the line's
+			// character limit
+			if w.lineLen+w.space.Len()+w.word.PrintableRuneCount() > w.Limit &&
+				w.word.PrintableRuneCount() < w.Limit {
+				w.addNewLine()
+			}
+		}
+	}
+
+	return len(b), nil
+}
+
+// Close will finish the word-wrap operation. Always call it before trying to
+// retrieve the final result.
+func (w *WordWrap) Close() error {
+	w.addWord()
+	return nil
+}
+
+// Bytes returns the word-wrapped result as a byte slice.
+func (w *WordWrap) Bytes() []byte {
+	return w.buf.Bytes()
+}
+
+// String returns the word-wrapped result as a string.
+func (w *WordWrap) String() string {
+	return w.buf.String()
+}