package parse
import (
"bufio"
"bytes"
"errors"
"fmt"
"io"
"os"
"regexp"
"strconv"
"strings"
"git.sr.ht/~rjarry/aerc/log"
"github.com/gdamore/tcell/v2"
"github.com/gdamore/tcell/v2/terminfo"
"github.com/mattn/go-runewidth"
)
var AnsiReg = regexp.MustCompile("\x1B\\[[0-?]*[ -/]*[@-~]")
// StripAnsi strips ansi escape codes from the reader
func StripAnsi(r io.Reader) io.Reader {
buf := bytes.NewBuffer(nil)
scanner := bufio.NewScanner(r)
scanner.Buffer(nil, 1024*1024*1024)
for scanner.Scan() {
line := scanner.Bytes()
line = AnsiReg.ReplaceAll(line, []byte(""))
_, err := buf.Write(line)
if err != nil {
log.Warnf("failed write ", err)
}
_, err = buf.Write([]byte("\n"))
if err != nil {
log.Warnf("failed write ", err)
}
}
if err := scanner.Err(); err != nil {
fmt.Fprintf(os.Stderr, "failed to read line: %v\n", err)
}
return buf
}
// StyledRune is a rune and it's associated style. The rune has already been
// measured using go-runewidth
type StyledRune struct {
Value rune
Width int
Style tcell.Style
}
// RuneBuffer is a buffer of runes styled with tcell.Style objects
type RuneBuffer struct {
buf []*StyledRune
}
// Returns the internal slice of styled runes
func (rb *RuneBuffer) Runes() []*StyledRune {
return rb.buf
}
// Write writes a rune and it's associated style to the RuneBuffer
func (rb *RuneBuffer) Write(r rune, style tcell.Style) {
w := runewidth.RuneWidth(r)
rb.buf = append(rb.buf, &StyledRune{r, w, style})
}
// Prepend inserts the rune at the beginning of the rune buffer
func (rb *RuneBuffer) PadLeft(width int, r rune, style tcell.Style) {
w := rb.Len()
if w >= width {
return
}
w = width - w
for w > 0 {
ww := runewidth.RuneWidth(r)
w -= ww
rb.buf = append([]*StyledRune{{r, ww, style}}, rb.buf...)
}
}
func (rb *RuneBuffer) PadRight(width int, r rune, style tcell.Style) {
w := rb.Len()
if w >= width {
return
}
w = width - w
for w > 0 {
ww := runewidth.RuneWidth(r)
w -= ww
rb.buf = append(rb.buf, &StyledRune{r, ww, style})
}
}
// String outputs a styled-string using TERM=xterm-256color
func (rb *RuneBuffer) String() string {
return rb.string(0, false, 0)
}
// string returns a string no longer than n runes. If 'left' is true, the left
// side of the text is truncated. Pass 0 to return the full string
func (rb *RuneBuffer) string(n int, left bool, char rune) string {
// Use xterm-256color to generate the string. Ultimately all output will
// be re-parsed as 'xterm-256color' and tcell will handle the final
// output sequences based on the user's TERM
ti, err := terminfo.LookupTerminfo("xterm-256color")
if err != nil {
// Who knows what happened
return ""
}
var (
s = strings.Builder{}
style = tcell.StyleDefault
hasStyle = false
// w will track the length we have written, or would have
// written in the case of left truncate
w = 0
offset = 0
)
if left {
offset = rb.Len() - n
}
for _, r := range rb.buf {
if style != r.Style {
hasStyle = true
style = r.Style
s.WriteString(ti.AttrOff)
fg, bg, attrs := style.Decompose()
switch {
case fg.IsRGB() && bg.IsRGB() && ti.SetFgBgRGB != "":
fr, fg, fb := fg.RGB()
br, bg, bb := bg.RGB()
s.WriteString(ti.TParm(
ti.SetFgBgRGB,
int(fr),
int(fg),
int(fb),
int(br),
int(bg),
int(bb),
))
case fg.IsRGB() && ti.SetFgRGB != "":
// RGB
r, g, b := fg.RGB()
s.WriteString(ti.TParm(ti.SetFgRGB, int(r), int(g), int(b)))
case bg.IsRGB() && ti.SetBgRGB != "":
// RGB
r, g, b := bg.RGB()
s.WriteString(ti.TParm(ti.SetBgRGB, int(r), int(g), int(b)))
// Indexed
case fg.Valid() && bg.Valid() && ti.SetFgBg != "":
s.WriteString(ti.TParm(ti.SetFgBg, int(fg&0xff), int(bg&0xff)))
case fg.Valid() && ti.SetFg != "":
s.WriteString(ti.TParm(ti.SetFg, int(fg&0xff)))
case bg.Valid() && ti.SetBg != "":
s.WriteString(ti.TParm(ti.SetBg, int(bg&0xff)))
}
if attrs&tcell.AttrBold != 0 {
s.WriteString(ti.Bold)
}
if attrs&tcell.AttrUnderline != 0 {
s.WriteString(ti.Underline)
}
if attrs&tcell.AttrReverse != 0 {
s.WriteString(ti.Reverse)
}
if attrs&tcell.AttrBlink != 0 {
s.WriteString(ti.Blink)
}
if attrs&tcell.AttrDim != 0 {
s.WriteString(ti.Dim)
}
if attrs&tcell.AttrItalic != 0 {
s.WriteString(ti.Italic)
}
if attrs&tcell.AttrStrikeThrough != 0 {
s.WriteString(ti.StrikeThrough)
}
}
w += r.Width
if left && w <= offset {
if w == offset && char != 0 {
s.WriteRune(char)
}
continue
}
s.WriteRune(r.Value)
if n != 0 && !left && w == n {
if char != 0 {
s.WriteRune(char)
}
break
}
}
if hasStyle {
s.WriteString(ti.AttrOff)
}
return s.String()
}
// Len is the length of the string, without ansi sequences
func (rb *RuneBuffer) Len() int {
l := 0
for _, r := range rb.buf {
l += r.Width
}
return l
}
// Truncates to a width of n, optionally append a character to the string.
// Appending via Truncate allows the character to retain the same style as the
// string at the truncated location
func (rb *RuneBuffer) Truncate(n int, char rune) string {
return rb.string(n, false, char)
}
// Truncates a width of n off the beginning of the string, optionally append a
// character to the string. Appending via Truncate allows the character to
// retain the same style as the string at the truncated location
func (rb *RuneBuffer) TruncateHead(n int, char rune) string {
return rb.string(n, true, char)
}
// Applies a style to the buffer. Any currently applied styles will not be
// overwritten
func (rb *RuneBuffer) ApplyStyle(style tcell.Style) {
for _, sr := range rb.buf {
if sr.Style == tcell.StyleDefault {
sr.Style = style
}
}
}
// ApplyAttrs applies the style, and if another style is present ORs the
// attributes
func (rb *RuneBuffer) ApplyAttrs(style tcell.Style) {
fg, bg, attrs := style.Decompose()
for _, sr := range rb.buf {
srFg, srBg, srAttrs := sr.Style.Decompose()
if fg != tcell.ColorDefault {
srFg = fg
}
if bg != tcell.ColorDefault {
srBg = bg
}
sr.Style = sr.Style.Attributes(attrs | srAttrs).
Foreground(srFg).Background(srBg)
}
}
// Applies a style to a string. Any currently applied styles will not be overwritten
func ApplyStyle(style tcell.Style, str string) string {
rb := ParseANSI(str)
for _, sr := range rb.buf {
if sr.Style == tcell.StyleDefault {
sr.Style = style
}
}
return rb.String()
}
// Parses a styled string into a RuneBuffer
func ParseANSI(s string) *RuneBuffer {
p := &parser{
buf: &RuneBuffer{},
curStyle: tcell.StyleDefault,
}
rdr := strings.NewReader(s)
for {
r, _, err := rdr.ReadRune()
if err == io.EOF {
break
}
switch r {
case 0x1b:
p.handleSeq(rdr)
default:
p.buf.Write(r, p.curStyle)
}
}
return p.buf
}
// A parser parses a string into a RuneBuffer
type parser struct {
buf *RuneBuffer
curStyle tcell.Style
}
func (p *parser) handleSeq(rdr io.RuneReader) {
r, _, err := rdr.ReadRune()
if errors.Is(err, io.EOF) {
return
}
switch r {
case '[': // CSI
p.handleCSI(rdr)
case ']': // OSC
case '(': // Designate G0 charset
p.swallow(rdr, 1)
}
}
func (p *parser) handleCSI(rdr io.RuneReader) {
var (
params []int
param []rune
hasErr bool
er error
)
outer:
for {
r, _, err := rdr.ReadRune()
if errors.Is(err, io.EOF) {
return
}
switch {
case r >= 0x30 && r <= 0x39:
param = append(param, r)
case r == ':' || r == ';':
var ps int
if len(param) > 0 {
ps, er = strconv.Atoi(string(param))
if er != nil {
hasErr = true
continue
}
}
params = append(params, ps)
param = []rune{}
case r == 'm':
var ps int
if len(param) > 0 {
ps, er = strconv.Atoi(string(param))
if er != nil {
hasErr = true
continue
}
}
params = append(params, ps)
break outer
}
}
if hasErr {
// leave the cursor unchanged
return
}
for i := 0; i < len(params); i++ {
param := params[i]
switch param {
case 0:
p.curStyle = tcell.StyleDefault
case 1:
p.curStyle = p.curStyle.Bold(true)
case 2:
p.curStyle = p.curStyle.Dim(true)
case 3:
p.curStyle = p.curStyle.Italic(true)
case 4:
p.curStyle = p.curStyle.Underline(true)
case 5:
p.curStyle = p.curStyle.Blink(true)
case 6:
// rapid blink, not supported by tcell. fallback to slow
// blink
p.curStyle = p.curStyle.Blink(true)
case 7:
p.curStyle = p.curStyle.Reverse(true)
case 8:
// Hidden. not supported by tcell
case 9:
p.curStyle = p.curStyle.StrikeThrough(true)
case 21:
p.curStyle = p.curStyle.Bold(false)
case 22:
p.curStyle = p.curStyle.Dim(false)
case 23:
p.curStyle = p.curStyle.Italic(false)
case 24:
p.curStyle = p.curStyle.Underline(false)
case 25:
p.curStyle = p.curStyle.Blink(false)
case 26:
// rapid blink, not supported by tcell. fallback to slow
// blink
p.curStyle = p.curStyle.Blink(false)
case 27:
p.curStyle = p.curStyle.Reverse(false)
case 28:
// Hidden. unsupported by tcell
case 29:
p.curStyle = p.curStyle.StrikeThrough(false)
case 30, 31, 32, 33, 34, 35, 36, 37:
p.curStyle = p.curStyle.Foreground(tcell.PaletteColor(param - 30))
case 38:
if i+2 < len(params) && params[i+1] == 5 {
p.curStyle = p.curStyle.Foreground(tcell.PaletteColor(params[i+2]))
i += 2
}
if i+4 < len(params) && params[i+1] == 2 {
switch len(params) {
case 6:
r := int32(params[i+3])
g := int32(params[i+4])
b := int32(params[i+5])
p.curStyle = p.curStyle.Foreground(tcell.NewRGBColor(r, g, b))
i += 5
default:
r := int32(params[i+2])
g := int32(params[i+3])
b := int32(params[i+4])
p.curStyle = p.curStyle.Foreground(tcell.NewRGBColor(r, g, b))
i += 4
}
}
case 40, 41, 42, 43, 44, 45, 46, 47:
p.curStyle = p.curStyle.Background(tcell.PaletteColor(param - 40))
case 48:
if i+2 < len(params) && params[i+1] == 5 {
p.curStyle = p.curStyle.Background(tcell.PaletteColor(params[i+2]))
i += 2
}
if i+4 < len(params) && params[i+1] == 2 {
switch len(params) {
case 6:
r := int32(params[i+3])
g := int32(params[i+4])
b := int32(params[i+5])
p.curStyle = p.curStyle.Background(tcell.NewRGBColor(r, g, b))
i += 5
default:
r := int32(params[i+2])
g := int32(params[i+3])
b := int32(params[i+4])
p.curStyle = p.curStyle.Background(tcell.NewRGBColor(r, g, b))
i += 4
}
}
case 90, 91, 92, 93, 94, 95, 96, 97:
p.curStyle = p.curStyle.Foreground(tcell.PaletteColor(param - 90 + 8))
case 100, 101, 102, 103, 104, 105, 106, 107:
p.curStyle = p.curStyle.Background(tcell.PaletteColor(param - 100 + 8))
}
}
}
func (p *parser) swallow(rdr io.RuneReader, n int) {
for i := 0; i < n; i++ {
rdr.ReadRune() //nolint:errcheck // we are throwing these reads away
}
}
