text: handle hyperlink embedded text correctly; fixes #329 (#334)

Author: jedib0t

text/escape.go

@@ -0,0 +1,201 @@
+package text
+
+import (
+"fmt"
+"sort"
+"strconv"
+"strings"
+)
+
+// Constants
+const (
+EscapeReset = EscapeResetCSI
+EscapeResetCSI = EscapeStartCSI + "0" + EscapeStopCSI
+EscapeResetOSI = EscapeStartOSI + "0" + EscapeStopOSI
+EscapeStart = EscapeStartCSI
+EscapeStartCSI = "\x1b["
+EscapeStartOSI = "\x1b]"
+EscapeStartRune = rune(27) // \x1b
+EscapeStartRuneCSI = '[' // [
+EscapeStartRuneOSI = ']' // ]
+EscapeStop = EscapeStopCSI
+EscapeStopCSI = "m"
+EscapeStopOSI = "\\"
+EscapeStopRune = EscapeStopRuneCSI
+EscapeStopRuneCSI = 'm'
+EscapeStopRuneOSI = '\\'
+)
+
+// Deprecated Constants
+const (
+CSIStartRune = EscapeStartRuneCSI
+CSIStopRune = EscapeStopRuneCSI
+OSIStartRune = EscapeStartRuneOSI
+OSIStopRune = EscapeStopRuneOSI
+)
+
+type escSeqKind int
+
+const (
+escSeqKindUnknown escSeqKind = iota
+escSeqKindCSI
+escSeqKindOSI
+)
+
+type escSeqParser struct {
+codes map[int]bool
+
+// consume specific
+inEscSeq bool
+escSeqKind escSeqKind
+escapeSeq string
+}
+
+func (s *escSeqParser) Codes() []int {
+codes := make([]int, 0)
+for code, val := range s.codes {
+if val {
+codes = append(codes, code)
+}
+}
+sort.Ints(codes)
+return codes
+}
+
+func (s *escSeqParser) Consume(char rune) {
+if !s.inEscSeq && char == EscapeStartRune {
+s.inEscSeq = true
+s.escSeqKind = escSeqKindUnknown
+s.escapeSeq = ""
+} else if s.inEscSeq && s.escSeqKind == escSeqKindUnknown {
+if char == EscapeStartRuneCSI {
+s.escSeqKind = escSeqKindCSI
+} else if char == EscapeStartRuneOSI {
+s.escSeqKind = escSeqKindOSI
+}
+}
+
+if s.inEscSeq {
+s.escapeSeq += string(char)
+
+if s.isEscapeStopRune(char) {
+s.ParseSeq(s.escapeSeq, s.escSeqKind)
+s.Reset()
+}
+}
+}
+
+func (s *escSeqParser) InSequence() bool {
+return s.inEscSeq
+}
+
+func (s *escSeqParser) IsOpen() bool {
+return len(s.codes) > 0
+}
+
+func (s *escSeqParser) Reset() {
+s.inEscSeq = false
+s.escSeqKind = escSeqKindUnknown
+s.escapeSeq = ""
+}
+
+const (
+escCodeResetAll = 0
+escCodeResetIntensity = 22
+escCodeResetItalic = 23
+escCodeResetUnderline = 24
+escCodeResetBlink = 25
+escCodeResetReverse = 27
+escCodeResetCrossedOut = 29
+escCodeBold = 1
+escCodeDim = 2
+escCodeItalic = 3
+escCodeUnderline = 4
+escCodeBlinkSlow = 5
+escCodeBlinkRapid = 6
+escCodeReverse = 7
+escCodeConceal = 8
+escCodeCrossedOut = 9
+)
+
+func (s *escSeqParser) ParseSeq(seq string, seqKind escSeqKind) {
+if s.codes == nil {
+s.codes = make(map[int]bool)
+}
+
+if seqKind == escSeqKindOSI {
+seq = strings.Replace(seq, EscapeStartOSI, "", 1)
+seq = strings.Replace(seq, EscapeStopOSI, "", 1)
+} else { // escSeqKindCSI
+seq = strings.Replace(seq, EscapeStartCSI, "", 1)
+seq = strings.Replace(seq, EscapeStopCSI, "", 1)
+}
+
+codes := strings.Split(seq, ";")
+for _, code := range codes {
+code = strings.TrimSpace(code)
+if codeNum, err := strconv.Atoi(code); err == nil {
+switch codeNum {
+case escCodeResetAll:
+s.codes = make(map[int]bool) // clear everything
+case escCodeResetIntensity:
+delete(s.codes, escCodeBold)
+delete(s.codes, escCodeDim)
+case escCodeResetItalic:
+delete(s.codes, escCodeItalic)
+case escCodeResetUnderline:
+delete(s.codes, escCodeUnderline)
+case escCodeResetBlink:
+delete(s.codes, escCodeBlinkSlow)
+delete(s.codes, escCodeBlinkRapid)
+case escCodeResetReverse:
+delete(s.codes, escCodeReverse)
+case escCodeResetCrossedOut:
+delete(s.codes, escCodeCrossedOut)
+default:
+s.codes[codeNum] = true
+}
+}
+}
+}
+
+func (s *escSeqParser) ParseString(str string) string {
+s.escapeSeq, s.inEscSeq, s.escSeqKind = "", false, escSeqKindUnknown
+for _, char := range str {
+s.Consume(char)
+}
+return s.Sequence()
+}
+
+func (s *escSeqParser) Sequence() string {
+out := strings.Builder{}
+if s.IsOpen() {
+out.WriteString(EscapeStart)
+for idx, code := range s.Codes() {
+if idx > 0 {
+out.WriteRune(';')
+}
+out.WriteString(fmt.Sprint(code))
+}
+out.WriteString(EscapeStop)
+}
+
+return out.String()
+}
+
+const (
+escapeStartConcealOSI = "\x1b]8;"
+escapeStopConcealOSI = "\x1b\\"
+)
+
+func (s *escSeqParser) isEscapeStopRune(char rune) bool {
+if strings.HasPrefix(s.escapeSeq, escapeStartConcealOSI) {
+if strings.HasSuffix(s.escapeSeq, escapeStopConcealOSI) {
+return true
+}
+} else if (s.escSeqKind == escSeqKindCSI && char == EscapeStopRuneCSI) ||
+(s.escSeqKind == escSeqKindOSI && char == EscapeStopRuneOSI) {
+return true
+}
+return false
+}

text/escape_seq_parser.go

@@ -0,0 +1,74 @@
+package text
+
+import (
+"github.com/stretchr/testify/assert"
+"testing"
+)
+
+func Test_escSeqParser(t *testing.T) {
+t.Run("extract csi", func(t *testing.T) {
+es := escSeqParser{}
+
+assert.Equal(t, "\x1b[1;3;4;5;7;9;91m", es.ParseString("\x1b[91m\x1b[1m\x1b[3m\x1b[4m\x1b[5m\x1b[7m\x1b[9m Spicy"))
+assert.Equal(t, "\x1b[3;4;5;7;9;91m", es.ParseString("\x1b[22m No Bold"))
+assert.Equal(t, "\x1b[4;5;7;9;91m", es.ParseString("\x1b[23m No Italic"))
+assert.Equal(t, "\x1b[5;7;9;91m", es.ParseString("\x1b[24m No Underline"))
+assert.Equal(t, "\x1b[7;9;91m", es.ParseString("\x1b[25m No Blink"))
+assert.Equal(t, "\x1b[9;91m", es.ParseString("\x1b[27m No Reverse"))
+assert.Equal(t, "\x1b[91m", es.ParseString("\x1b[29m No Crossed-Out"))
+assert.Equal(t, "", es.ParseString("\x1b[0m Resetted"))
+})
+
+t.Run("extract osi", func(t *testing.T) {
+es := escSeqParser{}
+
+assert.Equal(t, "\x1b[1;3;4;5;7;9;91m", es.ParseString("\x1b]91\\\x1b]1\\\x1b]3\\\x1b]4\\\x1b]5\\\x1b]7\\\x1b]9\\ Spicy"))
+assert.Equal(t, "\x1b[3;4;5;7;9;91m", es.ParseString("\x1b]22\\ No Bold"))
+assert.Equal(t, "\x1b[4;5;7;9;91m", es.ParseString("\x1b]23\\ No Italic"))
+assert.Equal(t, "\x1b[5;7;9;91m", es.ParseString("\x1b]24\\ No Underline"))
+assert.Equal(t, "\x1b[7;9;91m", es.ParseString("\x1b]25\\ No Blink"))
+assert.Equal(t, "\x1b[9;91m", es.ParseString("\x1b]27\\ No Reverse"))
+assert.Equal(t, "\x1b[91m", es.ParseString("\x1b]29\\ No Crossed-Out"))
+assert.Equal(t, "", es.ParseString("\x1b[0m Resetted"))
+})
+
+t.Run("parse csi", func(t *testing.T) {
+es := escSeqParser{}
+
+es.ParseSeq("\x1b[91m", escSeqKindCSI) // color
+es.ParseSeq("\x1b[1m", escSeqKindCSI) // bold
+assert.Len(t, es.Codes(), 2)
+assert.True(t, es.IsOpen())
+assert.Equal(t, "\x1b[1;91m", es.Sequence())
+
+es.ParseSeq("\x1b[22m", escSeqKindCSI) // un-bold
+assert.Len(t, es.Codes(), 1)
+assert.True(t, es.IsOpen())
+assert.Equal(t, "\x1b[91m", es.Sequence())
+
+es.ParseSeq("\x1b[0m", escSeqKindCSI) // reset
+assert.Empty(t, es.Codes())
+assert.False(t, es.IsOpen())
+assert.Empty(t, es.Sequence())
+})
+
+t.Run("parse osi", func(t *testing.T) {
+es := escSeqParser{}
+
+es.ParseSeq("\x1b]91\\", escSeqKindOSI) // color
+es.ParseSeq("\x1b]1\\", escSeqKindOSI) // bold
+assert.Len(t, es.Codes(), 2)
+assert.True(t, es.IsOpen())
+assert.Equal(t, "\x1b[1;91m", es.Sequence())
+
+es.ParseSeq("\x1b]22\\", escSeqKindOSI) // un-bold
+assert.Len(t, es.Codes(), 1)
+assert.True(t, es.IsOpen())
+assert.Equal(t, "\x1b[91m", es.Sequence())
+
+es.ParseSeq("\x1b]0\\", escSeqKindOSI) // reset
+assert.Empty(t, es.Codes())
+assert.False(t, es.IsOpen())
+assert.Empty(t, es.Sequence())
+})
+}